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


f8bf8a2491b9a816dff5824ed373853384e26510
[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_wxClipboardTextEvent swig_types[21]
2484 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2485 #define SWIGTYPE_p_wxColour swig_types[23]
2486 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2487 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2488 #define SWIGTYPE_p_wxControl swig_types[26]
2489 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2490 #define SWIGTYPE_p_wxCursor swig_types[28]
2491 #define SWIGTYPE_p_wxDC swig_types[29]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2493 #define SWIGTYPE_p_wxDateTime swig_types[31]
2494 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2496 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2497 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEvent swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2500 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2501 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2502 #define SWIGTYPE_p_wxFSFile swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2504 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2505 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2506 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2507 #define SWIGTYPE_p_wxFont swig_types[45]
2508 #define SWIGTYPE_p_wxFrame swig_types[46]
2509 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2510 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2511 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2512 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2513 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2514 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2515 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2516 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2517 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2518 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2519 #define SWIGTYPE_p_wxImage swig_types[57]
2520 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2521 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2522 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2523 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2524 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2525 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2526 #define SWIGTYPE_p_wxInputStream swig_types[64]
2527 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2528 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2529 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2530 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2531 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2532 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2533 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2534 #define SWIGTYPE_p_wxMenu swig_types[72]
2535 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2536 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2537 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2539 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2540 #define SWIGTYPE_p_wxMouseEvent swig_types[78]
2541 #define SWIGTYPE_p_wxMoveEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxNcPaintEvent swig_types[81]
2544 #define SWIGTYPE_p_wxNotifyEvent swig_types[82]
2545 #define SWIGTYPE_p_wxObject swig_types[83]
2546 #define SWIGTYPE_p_wxOutputStream swig_types[84]
2547 #define SWIGTYPE_p_wxPCXHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPNGHandler swig_types[86]
2549 #define SWIGTYPE_p_wxPNMHandler swig_types[87]
2550 #define SWIGTYPE_p_wxPaintEvent swig_types[88]
2551 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[89]
2552 #define SWIGTYPE_p_wxPaperSize swig_types[90]
2553 #define SWIGTYPE_p_wxPoint swig_types[91]
2554 #define SWIGTYPE_p_wxPoint2D swig_types[92]
2555 #define SWIGTYPE_p_wxPropagateOnce swig_types[93]
2556 #define SWIGTYPE_p_wxPropagationDisabler swig_types[94]
2557 #define SWIGTYPE_p_wxPyApp swig_types[95]
2558 #define SWIGTYPE_p_wxPyCommandEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyDropTarget swig_types[97]
2560 #define SWIGTYPE_p_wxPyEvent swig_types[98]
2561 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[99]
2562 #define SWIGTYPE_p_wxPyImageHandler swig_types[100]
2563 #define SWIGTYPE_p_wxPyInputStream swig_types[101]
2564 #define SWIGTYPE_p_wxPySizer swig_types[102]
2565 #define SWIGTYPE_p_wxPyValidator swig_types[103]
2566 #define SWIGTYPE_p_wxQuantize swig_types[104]
2567 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[105]
2568 #define SWIGTYPE_p_wxRealPoint swig_types[106]
2569 #define SWIGTYPE_p_wxRect swig_types[107]
2570 #define SWIGTYPE_p_wxRegion swig_types[108]
2571 #define SWIGTYPE_p_wxScrollEvent swig_types[109]
2572 #define SWIGTYPE_p_wxScrollWinEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSetCursorEvent swig_types[111]
2574 #define SWIGTYPE_p_wxShowEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSize swig_types[113]
2576 #define SWIGTYPE_p_wxSizeEvent swig_types[114]
2577 #define SWIGTYPE_p_wxSizer swig_types[115]
2578 #define SWIGTYPE_p_wxSizerItem swig_types[116]
2579 #define SWIGTYPE_p_wxStaticBox swig_types[117]
2580 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[118]
2581 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[119]
2582 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[120]
2583 #define SWIGTYPE_p_wxTIFFHandler swig_types[121]
2584 #define SWIGTYPE_p_wxToolTip swig_types[122]
2585 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[123]
2586 #define SWIGTYPE_p_wxValidator swig_types[124]
2587 #define SWIGTYPE_p_wxVisualAttributes swig_types[125]
2588 #define SWIGTYPE_p_wxWindow swig_types[126]
2589 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[127]
2590 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[128]
2591 #define SWIGTYPE_p_wxXPMHandler swig_types[129]
2592 #define SWIGTYPE_p_wxZipFSHandler swig_types[130]
2593 static swig_type_info *swig_types[132];
2594 static swig_module_info swig_module = {swig_types, 131, 0, 0, 0, 0};
2595 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2596 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2597
2598 /* -------- TYPES TABLE (END) -------- */
2599
2600 #if (PY_VERSION_HEX <= 0x02000000)
2601 # if !defined(SWIG_PYTHON_CLASSIC)
2602 # error "This python version requires to use swig with the '-classic' option"
2603 # endif
2604 #endif
2605 #if (PY_VERSION_HEX <= 0x02020000)
2606 # error "This python version requires to use swig with the '-nomodern' option"
2607 #endif
2608 #if (PY_VERSION_HEX <= 0x02020000)
2609 # error "This python version requires to use swig with the '-nomodernargs' option"
2610 #endif
2611 #ifndef METH_O
2612 # error "This python version requires to use swig with the '-nofastunpack' option"
2613 #endif
2614
2615 /*-----------------------------------------------
2616 @(target):= _core_.so
2617 ------------------------------------------------*/
2618 #define SWIG_init init_core_
2619
2620 #define SWIG_name "_core_"
2621
2622 #define SWIGVERSION 0x010329
2623
2624
2625 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2626 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2627
2628
2629 #include <stdexcept>
2630
2631
2632 namespace swig {
2633 class PyObject_ptr {
2634 protected:
2635 PyObject *_obj;
2636
2637 public:
2638 PyObject_ptr() :_obj(0)
2639 {
2640 }
2641
2642 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2643 {
2644 Py_XINCREF(_obj);
2645 }
2646
2647 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2648 {
2649 if (initial_ref) Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr & operator=(const PyObject_ptr& item)
2653 {
2654 Py_XINCREF(item._obj);
2655 Py_XDECREF(_obj);
2656 _obj = item._obj;
2657 return *this;
2658 }
2659
2660 ~PyObject_ptr()
2661 {
2662 Py_XDECREF(_obj);
2663 }
2664
2665 operator PyObject *() const
2666 {
2667 return _obj;
2668 }
2669
2670 PyObject *operator->() const
2671 {
2672 return _obj;
2673 }
2674 };
2675 }
2676
2677
2678 namespace swig {
2679 struct PyObject_var : PyObject_ptr {
2680 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2681
2682 PyObject_var & operator = (PyObject* obj)
2683 {
2684 Py_XDECREF(_obj);
2685 _obj = obj;
2686 return *this;
2687 }
2688 };
2689 }
2690
2691
2692 #include "wx/wxPython/wxPython_int.h"
2693 #include "wx/wxPython/pyclasses.h"
2694 #include "wx/wxPython/twoitem.h"
2695
2696
2697 #ifndef wxPyUSE_EXPORT
2698 // Helper functions for dealing with SWIG objects and such. These are
2699 // located here so they know about the SWIG types and functions declared
2700 // in the wrapper code.
2701
2702 #include <wx/hashmap.h>
2703 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2704
2705
2706 // Maintains a hashmap of className to swig_type_info pointers. Given the
2707 // name of a class either looks up the type info in the cache, or scans the
2708 // SWIG tables for it.
2709 extern PyObject* wxPyPtrTypeMap;
2710 static
2711 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2712
2713 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2714
2715 if (typeInfoCache == NULL)
2716 typeInfoCache = new wxPyTypeInfoHashMap;
2717
2718 wxString name(className);
2719 swig_type_info* swigType = (*typeInfoCache)[name];
2720
2721 if (! swigType) {
2722 // it wasn't in the cache, so look it up from SWIG
2723 name.Append(wxT(" *"));
2724 swigType = SWIG_TypeQuery(name.mb_str());
2725
2726 // if it still wasn't found, try looking for a mapped name
2727 if (!swigType) {
2728 PyObject* item;
2729 name = className;
2730
2731 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2732 (char*)(const char*)name.mbc_str())) != NULL) {
2733 name = wxString(PyString_AsString(item), *wxConvCurrent);
2734 name.Append(wxT(" *"));
2735 swigType = SWIG_TypeQuery(name.mb_str());
2736 }
2737 }
2738 if (swigType) {
2739 // and add it to the map if found
2740 (*typeInfoCache)[className] = swigType;
2741 }
2742 }
2743 return swigType;
2744 }
2745
2746
2747 // Check if a class name is a type known to SWIG
2748 bool wxPyCheckSwigType(const wxChar* className) {
2749
2750 swig_type_info* swigType = wxPyFindSwigType(className);
2751 return swigType != NULL;
2752 }
2753
2754
2755 // Given a pointer to a C++ object and a class name, construct a Python proxy
2756 // object for it.
2757 PyObject* wxPyConstructObject(void* ptr,
2758 const wxChar* className,
2759 int setThisOwn) {
2760
2761 swig_type_info* swigType = wxPyFindSwigType(className);
2762 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2763
2764 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2765 }
2766
2767
2768 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2769 // Ensures that the proxy object is of the specified (or derived) type. If
2770 // not able to perform the conversion then a Python exception is set and the
2771 // error should be handled properly in the caller. Returns True on success.
2772 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2773 const wxChar* className) {
2774
2775 swig_type_info* swigType = wxPyFindSwigType(className);
2776 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2777
2778 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2779 }
2780
2781
2782
2783 // Make a SWIGified pointer object suitable for a .this attribute
2784 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2785
2786 PyObject* robj = NULL;
2787
2788 swig_type_info* swigType = wxPyFindSwigType(className);
2789 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2790
2791 robj = PySwigObject_New(ptr, swigType, 0);
2792 return robj;
2793 }
2794
2795
2796 // Python's PyInstance_Check does not return True for instances of new-style
2797 // classes. This should get close enough for both new and old classes but I
2798 // should re-evaluate the need for doing instance checks...
2799 bool wxPyInstance_Check(PyObject* obj) {
2800 return PyObject_HasAttrString(obj, "__class__") != 0;
2801 }
2802
2803
2804 // This one checks if the object is an instance of a SWIG proxy class (it has
2805 // a .this attribute, and the .this attribute is a PySwigObject.)
2806 bool wxPySwigInstance_Check(PyObject* obj) {
2807 static PyObject* this_str = NULL;
2808 if (this_str == NULL)
2809 this_str = PyString_FromString("this");
2810
2811 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2812 if (this_attr) {
2813 bool retval = (PySwigObject_Check(this_attr) != 0);
2814 Py_DECREF(this_attr);
2815 return retval;
2816 }
2817
2818 PyErr_Clear();
2819 return false;
2820 }
2821
2822
2823 // Export a C API in a struct. Other modules will be able to load this from
2824 // the wx._core_ module and will then have safe access to these functions,
2825 // even if they are located in another shared library.
2826 static wxPyCoreAPI API = {
2827
2828 wxPyCheckSwigType,
2829 wxPyConstructObject,
2830 wxPyConvertSwigPtr,
2831 wxPyMakeSwigPtr,
2832
2833 wxPyBeginAllowThreads,
2834 wxPyEndAllowThreads,
2835 wxPyBeginBlockThreads,
2836 wxPyEndBlockThreads,
2837
2838 wxPy_ConvertList,
2839
2840 wxString_in_helper,
2841 Py2wxString,
2842 wx2PyString,
2843
2844 byte_LIST_helper,
2845 int_LIST_helper,
2846 long_LIST_helper,
2847 string_LIST_helper,
2848 wxPoint_LIST_helper,
2849 wxBitmap_LIST_helper,
2850 wxString_LIST_helper,
2851 wxAcceleratorEntry_LIST_helper,
2852
2853 wxSize_helper,
2854 wxPoint_helper,
2855 wxRealPoint_helper,
2856 wxRect_helper,
2857 wxColour_helper,
2858 wxPoint2D_helper,
2859
2860 wxPySimple_typecheck,
2861 wxColour_typecheck,
2862
2863 wxPyCBH_setCallbackInfo,
2864 wxPyCBH_findCallback,
2865 wxPyCBH_callCallback,
2866 wxPyCBH_callCallbackObj,
2867 wxPyCBH_delete,
2868
2869 wxPyMake_wxObject,
2870 wxPyMake_wxSizer,
2871 wxPyPtrTypeMap_Add,
2872 wxPy2int_seq_helper,
2873 wxPy4int_seq_helper,
2874 wxArrayString2PyList_helper,
2875 wxArrayInt2PyList_helper,
2876
2877 wxPyClientData_dtor,
2878 wxPyUserData_dtor,
2879 wxPyOORClientData_dtor,
2880
2881 wxPyCBInputStream_create,
2882 wxPyCBInputStream_copy,
2883
2884 wxPyInstance_Check,
2885 wxPySwigInstance_Check,
2886
2887 wxPyCheckForApp
2888
2889 };
2890
2891 #endif
2892
2893
2894 #if !WXWIN_COMPATIBILITY_2_4
2895 #define wxHIDE_READONLY 0
2896 #endif
2897
2898
2899 #define SWIG_From_long PyInt_FromLong
2900
2901
2902 SWIGINTERNINLINE PyObject *
2903 SWIG_From_int (int value)
2904 {
2905 return SWIG_From_long (value);
2906 }
2907
2908 static const wxString wxPyEmptyString(wxEmptyString);
2909 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2910 return self->GetClassInfo()->GetClassName();
2911 }
2912 SWIGINTERN void wxObject_Destroy(wxObject *self){
2913 delete self;
2914 }
2915
2916 #ifndef __WXMAC__
2917 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2918 #endif
2919
2920
2921 #include <limits.h>
2922 #ifndef LLONG_MIN
2923 # define LLONG_MIN LONG_LONG_MIN
2924 #endif
2925 #ifndef LLONG_MAX
2926 # define LLONG_MAX LONG_LONG_MAX
2927 #endif
2928 #ifndef ULLONG_MAX
2929 # define ULLONG_MAX ULONG_LONG_MAX
2930 #endif
2931
2932
2933 SWIGINTERN int
2934 SWIG_AsVal_long (PyObject* obj, long* val)
2935 {
2936 if (PyNumber_Check(obj)) {
2937 if (val) *val = PyInt_AsLong(obj);
2938 return SWIG_OK;
2939 }
2940 return SWIG_TypeError;
2941 }
2942
2943
2944 SWIGINTERN int
2945 SWIG_AsVal_int (PyObject * obj, int *val)
2946 {
2947 long v;
2948 int res = SWIG_AsVal_long (obj, &v);
2949 if (SWIG_IsOK(res)) {
2950 if ((v < INT_MIN || v > INT_MAX)) {
2951 return SWIG_OverflowError;
2952 } else {
2953 if (val) *val = static_cast< int >(v);
2954 }
2955 }
2956 return res;
2957 }
2958
2959 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2960 wxSize temp, *obj = &temp;
2961 if ( other == Py_None ) return false;
2962 if ( ! wxSize_helper(other, &obj) ) {
2963 PyErr_Clear();
2964 return false;
2965 }
2966 return self->operator==(*obj);
2967 }
2968 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2969 wxSize temp, *obj = &temp;
2970 if ( other == Py_None ) return true;
2971 if ( ! wxSize_helper(other, &obj)) {
2972 PyErr_Clear();
2973 return true;
2974 }
2975 return self->operator!=(*obj);
2976 }
2977 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2978 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2979 PyObject* tup = PyTuple_New(2);
2980 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2981 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2982 wxPyEndBlockThreads(blocked);
2983 return tup;
2984 }
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 #define SWIG_From_double PyFloat_FromDouble
2998
2999 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3000 wxRealPoint temp, *obj = &temp;
3001 if ( other == Py_None ) return false;
3002 if ( ! wxRealPoint_helper(other, &obj) ) {
3003 PyErr_Clear();
3004 return false;
3005 }
3006 return self->operator==(*obj);
3007 }
3008 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3009 wxRealPoint temp, *obj = &temp;
3010 if ( other == Py_None ) return true;
3011 if ( ! wxRealPoint_helper(other, &obj)) {
3012 PyErr_Clear();
3013 return true;
3014 }
3015 return self->operator!=(*obj);
3016 }
3017 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3018 self->x = x;
3019 self->y = y;
3020 }
3021 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3022 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3023 PyObject* tup = PyTuple_New(2);
3024 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3025 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3026 wxPyEndBlockThreads(blocked);
3027 return tup;
3028 }
3029 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3030 wxPoint temp, *obj = &temp;
3031 if ( other == Py_None ) return false;
3032 if ( ! wxPoint_helper(other, &obj) ) {
3033 PyErr_Clear();
3034 return false;
3035 }
3036 return self->operator==(*obj);
3037 }
3038 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3039 wxPoint temp, *obj = &temp;
3040 if ( other == Py_None ) return true;
3041 if ( ! wxPoint_helper(other, &obj)) {
3042 PyErr_Clear();
3043 return true;
3044 }
3045 return self->operator!=(*obj);
3046 }
3047 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3048 self->x = x;
3049 self->y = y;
3050 }
3051 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3052 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3053 PyObject* tup = PyTuple_New(2);
3054 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3055 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3056 wxPyEndBlockThreads(blocked);
3057 return tup;
3058 }
3059 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3060 wxRect temp, *obj = &temp;
3061 if ( other == Py_None ) return false;
3062 if ( ! wxRect_helper(other, &obj) ) {
3063 PyErr_Clear();
3064 return false;
3065 }
3066 return self->operator==(*obj);
3067 }
3068 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3069 wxRect temp, *obj = &temp;
3070 if ( other == Py_None ) return true;
3071 if ( ! wxRect_helper(other, &obj)) {
3072 PyErr_Clear();
3073 return true;
3074 }
3075 return self->operator!=(*obj);
3076 }
3077 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3078 self->x = x;
3079 self->y = y;
3080 self->width = width;
3081 self->height = height;
3082 }
3083 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3084 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3085 PyObject* tup = PyTuple_New(4);
3086 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3087 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3088 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3089 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3090 wxPyEndBlockThreads(blocked);
3091 return tup;
3092 }
3093
3094 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3095 wxRegion reg1(*r1);
3096 wxRegion reg2(*r2);
3097 wxRect dest(0,0,0,0);
3098 PyObject* obj;
3099
3100 reg1.Intersect(reg2);
3101 dest = reg1.GetBox();
3102
3103 if (dest != wxRect(0,0,0,0)) {
3104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3105 wxRect* newRect = new wxRect(dest);
3106 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3107 wxPyEndBlockThreads(blocked);
3108 return obj;
3109 }
3110 Py_INCREF(Py_None);
3111 return Py_None;
3112 }
3113
3114 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3115 wxPoint2D temp, *obj = &temp;
3116 if ( other == Py_None ) return false;
3117 if ( ! wxPoint2D_helper(other, &obj) ) {
3118 PyErr_Clear();
3119 return false;
3120 }
3121 return self->operator==(*obj);
3122 }
3123 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3124 wxPoint2D temp, *obj = &temp;
3125 if ( other == Py_None ) return true;
3126 if ( ! wxPoint2D_helper(other, &obj)) {
3127 PyErr_Clear();
3128 return true;
3129 }
3130 return self->operator!=(*obj);
3131 }
3132 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3133 self->m_x = x;
3134 self->m_y = y;
3135 }
3136 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3137 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3138 PyObject* tup = PyTuple_New(2);
3139 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3140 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3141 wxPyEndBlockThreads(blocked);
3142 return tup;
3143 }
3144
3145 #include "wx/wxPython/pyistream.h"
3146
3147 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3148 wxInputStream* wxis = wxPyCBInputStream::create(p);
3149 if (wxis)
3150 return new wxPyInputStream(wxis);
3151 else
3152 return NULL;
3153 }
3154
3155 SWIGINTERN swig_type_info*
3156 SWIG_pchar_descriptor()
3157 {
3158 static int init = 0;
3159 static swig_type_info* info = 0;
3160 if (!init) {
3161 info = SWIG_TypeQuery("_p_char");
3162 init = 1;
3163 }
3164 return info;
3165 }
3166
3167
3168 SWIGINTERNINLINE PyObject *
3169 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3170 {
3171 if (carray) {
3172 if (size > INT_MAX) {
3173 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3174 return pchar_descriptor ?
3175 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3176 } else {
3177 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3178 }
3179 } else {
3180 return SWIG_Py_Void();
3181 }
3182 }
3183
3184
3185 SWIGINTERNINLINE PyObject *
3186 SWIG_From_char (char c)
3187 {
3188 return SWIG_FromCharPtrAndSize(&c,1);
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject*
3193 SWIG_From_unsigned_SS_long (unsigned long value)
3194 {
3195 return (value > LONG_MAX) ?
3196 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3197 }
3198
3199
3200 SWIGINTERNINLINE PyObject *
3201 SWIG_From_size_t (size_t value)
3202 {
3203 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3204 }
3205
3206
3207 SWIGINTERN int
3208 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3209 {
3210 if (PyString_Check(obj)) {
3211 char *cstr; int len;
3212 PyString_AsStringAndSize(obj, &cstr, &len);
3213 if (cptr) {
3214 if (alloc) {
3215 /*
3216 In python the user should not be able to modify the inner
3217 string representation. To warranty that, if you define
3218 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3219 buffer is always returned.
3220
3221 The default behavior is just to return the pointer value,
3222 so, be careful.
3223 */
3224 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3225 if (*alloc != SWIG_OLDOBJ)
3226 #else
3227 if (*alloc == SWIG_NEWOBJ)
3228 #endif
3229 {
3230 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3231 *alloc = SWIG_NEWOBJ;
3232 }
3233 else {
3234 *cptr = cstr;
3235 *alloc = SWIG_OLDOBJ;
3236 }
3237 } else {
3238 *cptr = PyString_AsString(obj);
3239 }
3240 }
3241 if (psize) *psize = len + 1;
3242 return SWIG_OK;
3243 } else {
3244 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3245 if (pchar_descriptor) {
3246 void* vptr = 0;
3247 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3248 if (cptr) *cptr = (char *) vptr;
3249 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3250 if (alloc) *alloc = SWIG_OLDOBJ;
3251 return SWIG_OK;
3252 }
3253 }
3254 }
3255 return SWIG_TypeError;
3256 }
3257
3258
3259 SWIGINTERN int
3260 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3261 {
3262 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3263 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3264 if (SWIG_IsOK(res)) {
3265 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3266 if (csize <= size) {
3267 if (val) {
3268 if (csize) memcpy(val, cptr, csize*sizeof(char));
3269 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3270 }
3271 if (alloc == SWIG_NEWOBJ) {
3272 delete[] cptr;
3273 res = SWIG_DelNewMask(res);
3274 }
3275 return res;
3276 }
3277 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsVal_char (PyObject * obj, char *val)
3285 {
3286 int res = SWIG_AsCharArray(obj, val, 1);
3287 if (!SWIG_IsOK(res)) {
3288 long v;
3289 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3290 if (SWIG_IsOK(res)) {
3291 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3292 if (val) *val = static_cast< char >(v);
3293 } else {
3294 res = SWIG_OverflowError;
3295 }
3296 }
3297 }
3298 return res;
3299 }
3300
3301 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3302 // We use only strings for the streams, not unicode
3303 PyObject* str = PyObject_Str(obj);
3304 if (! str) {
3305 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3306 return;
3307 }
3308 self->Write(PyString_AS_STRING(str),
3309 PyString_GET_SIZE(str));
3310 Py_DECREF(str);
3311 }
3312
3313 #include "wx/wxPython/pyistream.h"
3314
3315
3316 class wxPyFileSystemHandler : public wxFileSystemHandler
3317 {
3318 public:
3319 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3320
3321 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3322 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3323 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3324 DEC_PYCALLBACK_STRING__pure(FindNext);
3325
3326 wxString GetProtocol(const wxString& location) {
3327 return wxFileSystemHandler::GetProtocol(location);
3328 }
3329
3330 wxString GetLeftLocation(const wxString& location) {
3331 return wxFileSystemHandler::GetLeftLocation(location);
3332 }
3333
3334 wxString GetAnchor(const wxString& location) {
3335 return wxFileSystemHandler::GetAnchor(location);
3336 }
3337
3338 wxString GetRightLocation(const wxString& location) {
3339 return wxFileSystemHandler::GetRightLocation(location);
3340 }
3341
3342 wxString GetMimeTypeFromExt(const wxString& location) {
3343 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3344 }
3345
3346 PYPRIVATE;
3347 };
3348
3349
3350 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3351 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3352 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3353 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3354
3355
3356 SWIGINTERN int
3357 SWIG_AsVal_bool (PyObject *obj, bool *val)
3358 {
3359 if (obj == Py_True) {
3360 if (val) *val = true;
3361 return SWIG_OK;
3362 } else if (obj == Py_False) {
3363 if (val) *val = false;
3364 return SWIG_OK;
3365 } else {
3366 long v = 0;
3367 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3368 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3369 return res;
3370 }
3371 }
3372
3373 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3374 wxFileName fname = wxFileSystem::URLToFileName(url);
3375 return fname.GetFullPath();
3376 }
3377
3378 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3379 wxImage& image,
3380 long type) {
3381 wxMemoryFSHandler::AddFile(filename, image, type);
3382 }
3383
3384 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3385 const wxBitmap& bitmap,
3386 long type) {
3387 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3388 }
3389
3390 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3391 PyObject* data) {
3392 if (! PyString_Check(data)) {
3393 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3394 "Expected string object"));
3395 return;
3396 }
3397
3398 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3399 void* ptr = (void*)PyString_AsString(data);
3400 size_t size = PyString_Size(data);
3401 wxPyEndBlockThreads(blocked);
3402
3403 wxMemoryFSHandler::AddFile(filename, ptr, size);
3404 }
3405
3406
3407 #include "wx/wxPython/pyistream.h"
3408
3409
3410 SWIGINTERN int
3411 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3412 {
3413 long v = 0;
3414 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3415 return SWIG_TypeError;
3416 }
3417 else if (val)
3418 *val = (unsigned long)v;
3419 return SWIG_OK;
3420 }
3421
3422
3423 SWIGINTERN int
3424 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3425 {
3426 unsigned long v;
3427 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3428 if (SWIG_IsOK(res)) {
3429 if ((v > UCHAR_MAX)) {
3430 return SWIG_OverflowError;
3431 } else {
3432 if (val) *val = static_cast< unsigned char >(v);
3433 }
3434 }
3435 return res;
3436 }
3437
3438
3439 SWIGINTERNINLINE PyObject *
3440 SWIG_From_unsigned_SS_char (unsigned char value)
3441 {
3442 return SWIG_From_unsigned_SS_long (value);
3443 }
3444
3445 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3446 wxImageHistogramEntry e = (*self)[key];
3447 return e.value;
3448 }
3449 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3450 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3451 wxImageHistogramEntry e = (*self)[key];
3452 return e.value;
3453 }
3454 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3455 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3456 colour.Green(),
3457 colour.Blue());
3458 wxImageHistogramEntry e = (*self)[key];
3459 return e.value;
3460 }
3461
3462 typedef unsigned char* buffer;
3463
3464
3465 // Pull the nested class out to the top level for SWIG's sake
3466 #define wxImage_RGBValue wxImage::RGBValue
3467 #define wxImage_HSVValue wxImage::HSVValue
3468
3469 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3470 if (width > 0 && height > 0)
3471 return new wxImage(width, height, clear);
3472 else
3473 return new wxImage;
3474 }
3475 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3476 return new wxImage(bitmap.ConvertToImage());
3477 }
3478 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3479 if (DATASIZE != width*height*3) {
3480 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3481 return NULL;
3482 }
3483
3484 // Copy the source data so the wxImage can clean it up later
3485 buffer copy = (buffer)malloc(DATASIZE);
3486 if (copy == NULL) {
3487 wxPyBLOCK_THREADS(PyErr_NoMemory());
3488 return NULL;
3489 }
3490 memcpy(copy, data, DATASIZE);
3491 return new wxImage(width, height, copy, false);
3492 }
3493 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3494 if (DATASIZE != width*height*3) {
3495 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3496 return NULL;
3497 }
3498 if (ALPHASIZE != width*height) {
3499 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3500 return NULL;
3501 }
3502
3503 // Copy the source data so the wxImage can clean it up later
3504 buffer dcopy = (buffer)malloc(DATASIZE);
3505 if (dcopy == NULL) {
3506 wxPyBLOCK_THREADS(PyErr_NoMemory());
3507 return NULL;
3508 }
3509 memcpy(dcopy, data, DATASIZE);
3510
3511 buffer acopy = (buffer)malloc(ALPHASIZE);
3512 if (acopy == NULL) {
3513 wxPyBLOCK_THREADS(PyErr_NoMemory());
3514 return NULL;
3515 }
3516 memcpy(acopy, alpha, ALPHASIZE);
3517
3518 return new wxImage(width, height, dcopy, acopy, false);
3519 }
3520 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3521 wxSize size(self->GetWidth(), self->GetHeight());
3522 return size;
3523 }
3524 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3525 buffer data = self->GetData();
3526 int len = self->GetWidth() * self->GetHeight() * 3;
3527 PyObject* rv;
3528 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3529 return rv;
3530 }
3531 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3532 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3533 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3534 return;
3535 }
3536 buffer copy = (buffer)malloc(DATASIZE);
3537 if (copy == NULL) {
3538 wxPyBLOCK_THREADS(PyErr_NoMemory());
3539 return;
3540 }
3541 memcpy(copy, data, DATASIZE);
3542 self->SetData(copy, false);
3543 // wxImage takes ownership of copy...
3544 }
3545 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 self->SetData(data, true);
3558 }
3559 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3560 buffer data = self->GetAlpha();
3561 if (! data) {
3562 RETURN_NONE();
3563 } else {
3564 int len = self->GetWidth() * self->GetHeight();
3565 PyObject* rv;
3566 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3567 return rv;
3568 }
3569 }
3570 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3571 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3572 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3573 return;
3574 }
3575 buffer acopy = (buffer)malloc(ALPHASIZE);
3576 if (acopy == NULL) {
3577 wxPyBLOCK_THREADS(PyErr_NoMemory());
3578 return;
3579 }
3580 memcpy(acopy, alpha, ALPHASIZE);
3581 self->SetAlpha(acopy, false);
3582 // wxImage takes ownership of acopy...
3583 }
3584 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3585 buffer data = self->GetAlpha();
3586 int len = self->GetWidth() * self->GetHeight();
3587 PyObject* rv;
3588 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3589 return rv;
3590 }
3591 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 self->SetAlpha(alpha, true);
3597 }
3598 SWIGINTERN PyObject *wxImage_GetHandlers(){
3599 wxList& list = wxImage::GetHandlers();
3600 return wxPy_ConvertList(&list);
3601 }
3602 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3603 wxBitmap bitmap(*self, depth);
3604 return bitmap;
3605 }
3606 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3607 wxImage mono = self->ConvertToMono( red, green, blue );
3608 wxBitmap bitmap( mono, 1 );
3609 return bitmap;
3610 }
3611 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3612 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3613 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3614 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3616 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3617 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3618 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3619 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3620 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3621 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3622 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3623 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3624 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3625 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3626
3627 #include <wx/quantize.h>
3628
3629 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3630 return wxQuantize::Quantize(src, dest,
3631 //NULL, // palette
3632 desiredNoColours,
3633 NULL, // eightBitData
3634 flags);
3635 }
3636 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3637 if (PyCallable_Check(func)) {
3638 self->Connect(id, lastId, eventType,
3639 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3640 new wxPyCallback(func));
3641 }
3642 else if (func == Py_None) {
3643 self->Disconnect(id, lastId, eventType,
3644 (wxObjectEventFunction)
3645 &wxPyCallback::EventThunker);
3646 }
3647 else {
3648 wxPyBLOCK_THREADS(
3649 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3650 }
3651 }
3652 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3653 return self->Disconnect(id, lastId, eventType,
3654 (wxObjectEventFunction)
3655 &wxPyCallback::EventThunker);
3656 }
3657 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3658 if (_self && _self != Py_None) {
3659 self->SetClientObject(new wxPyOORClientData(_self, incref));
3660 }
3661 else {
3662 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3663 if (data) {
3664 self->SetClientObject(NULL); // This will delete it too
3665 }
3666 }
3667 }
3668
3669 #if ! wxUSE_HOTKEY
3670 #define wxEVT_HOTKEY -9999
3671 #endif
3672
3673 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3674 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3675 if (data) {
3676 Py_INCREF(data->m_obj);
3677 return data->m_obj;
3678 } else {
3679 Py_INCREF(Py_None);
3680 return Py_None;
3681 }
3682 }
3683 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3684 wxPyClientData* data = new wxPyClientData(clientData);
3685 self->SetClientObject(data);
3686 }
3687 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3688 #if wxUSE_UNICODE
3689 return self->GetUnicodeKey();
3690 #else
3691 return 0;
3692 #endif
3693 }
3694 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3695 #if wxUSE_UNICODE
3696 self->m_uniChar = uniChar;
3697 #endif
3698 }
3699
3700 SWIGINTERNINLINE PyObject *
3701 SWIG_From_unsigned_SS_int (unsigned int value)
3702 {
3703 return SWIG_From_unsigned_SS_long (value);
3704 }
3705
3706
3707 SWIGINTERN int
3708 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3709 {
3710 unsigned long v;
3711 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3712 if (SWIG_IsOK(res)) {
3713 if ((v > UINT_MAX)) {
3714 return SWIG_OverflowError;
3715 } else {
3716 if (val) *val = static_cast< unsigned int >(v);
3717 }
3718 }
3719 return res;
3720 }
3721
3722 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3723 self->m_size = size;
3724 }
3725 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3726 int count = self->GetNumberOfFiles();
3727 wxString* files = self->GetFiles();
3728 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3729 PyObject* list = PyList_New(count);
3730
3731 if (!list) {
3732 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3733 wxPyEndBlockThreads(blocked);
3734 return NULL;
3735 }
3736
3737 for (int i=0; i<count; i++) {
3738 PyList_SetItem(list, i, wx2PyString(files[i]));
3739 }
3740 wxPyEndBlockThreads(blocked);
3741 return list;
3742 }
3743
3744
3745 SWIGINTERN wxPyApp *new_wxPyApp(){
3746 wxPythonApp = new wxPyApp();
3747 return wxPythonApp;
3748 }
3749 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3750
3751 void wxApp_CleanUp() {
3752 __wxPyCleanup();
3753 }
3754
3755
3756 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3757
3758
3759
3760
3761
3762 SWIGINTERNINLINE PyObject *
3763 SWIG_FromCharPtr(const char *cptr)
3764 {
3765 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3766 }
3767
3768
3769 #if 0 // #ifdef __WXMAC__
3770
3771 // A dummy class that raises an exception if used...
3772 class wxEventLoop
3773 {
3774 public:
3775 wxEventLoop() { wxPyRaiseNotImplemented(); }
3776 int Run() { return 0; }
3777 void Exit(int rc = 0) {}
3778 bool Pending() const { return false; }
3779 bool Dispatch() { return false; }
3780 bool IsRunning() const { return false; }
3781 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3782 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3783 };
3784
3785 #else
3786
3787 #include <wx/evtloop.h>
3788
3789 #endif
3790
3791
3792
3793 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3794 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3795 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3796 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3797 wxWindowList& list = self->GetChildren();
3798 return wxPy_ConvertList(&list);
3799 }
3800 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3801 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3802 #if wxUSE_HOTKEY
3803 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3804 #else
3805 return false;
3806 #endif
3807 }
3808 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3809
3810
3811
3812 return false;
3813
3814 }
3815 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3816 return wxPyGetWinHandle(self);
3817 }
3818 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3819 self->AssociateHandle((WXWidget)handle);
3820 }
3821 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3822
3823 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3824 return wxWindow::FindWindowById(id, parent);
3825 }
3826
3827 wxWindow* wxFindWindowByName( const wxString& name,
3828 const wxWindow *parent = NULL ) {
3829 return wxWindow::FindWindowByName(name, parent);
3830 }
3831
3832 wxWindow* wxFindWindowByLabel( const wxString& label,
3833 const wxWindow *parent = NULL ) {
3834 return wxWindow::FindWindowByLabel(label, parent);
3835 }
3836
3837
3838 #ifdef __WXMSW__
3839 #include <wx/msw/private.h> // to get wxGetWindowId
3840 #endif
3841
3842
3843 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3844 #ifdef __WXMSW__
3845 WXHWND hWnd = (WXHWND)_hWnd;
3846 long id = wxGetWindowId(hWnd);
3847 wxWindow* win = new wxWindow;
3848 if (parent)
3849 parent->AddChild(win);
3850 win->SetEventHandler(win);
3851 win->SetHWND(hWnd);
3852 win->SetId(id);
3853 win->SubclassWin(hWnd);
3854 win->AdoptAttributesFromHWND();
3855 win->SetupColours();
3856 return win;
3857 #else
3858 wxPyRaiseNotImplemented();
3859 return NULL;
3860 #endif
3861 }
3862
3863
3864 PyObject* GetTopLevelWindows() {
3865 return wxPy_ConvertList(&wxTopLevelWindows);
3866 }
3867
3868
3869 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3870 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3871 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3872
3873 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3874
3875
3876 SWIGINTERNINLINE int
3877 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3878 {
3879 unsigned long v;
3880 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3881 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3882 return res;
3883 }
3884
3885 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3886 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3887 wxMenuItemList& list = self->GetMenuItems();
3888 return wxPy_ConvertList(&list);
3889 }
3890 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3891 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3892 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3893 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3894 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3895 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3896 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3897 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3898 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3899 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3900 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3901 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3902 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3903 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3904 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3905 static const wxString wxPyControlNameStr(wxControlNameStr);
3906 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3907 if (clientData) {
3908 wxPyClientData* data = new wxPyClientData(clientData);
3909 return self->Append(item, data);
3910 } else
3911 return self->Append(item);
3912 }
3913 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3914 if (clientData) {
3915 wxPyClientData* data = new wxPyClientData(clientData);
3916 return self->Insert(item, pos, data);
3917 } else
3918 return self->Insert(item, pos);
3919 }
3920 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3921 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3922 if (data) {
3923 Py_INCREF(data->m_obj);
3924 return data->m_obj;
3925 } else {
3926 Py_INCREF(Py_None);
3927 return Py_None;
3928 }
3929 }
3930 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3931 wxPyClientData* data = new wxPyClientData(clientData);
3932 self->SetClientObject(n, data);
3933 }
3934
3935
3936 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,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(window, proportion, flag, border, data);
3944 }
3945 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,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(width, height, proportion, flag, border, data);
3953 }
3954 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3955 wxPyUserData* data = NULL;
3956 if ( userData ) {
3957 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3958 data = new wxPyUserData(userData);
3959 wxPyEndBlockThreads(blocked);
3960 }
3961 return new wxSizerItem(sizer, proportion, flag, border, data);
3962 }
3963
3964 #include <float.h>
3965
3966
3967 SWIGINTERN int
3968 SWIG_AsVal_float (PyObject * obj, float *val)
3969 {
3970 double v;
3971 int res = SWIG_AsVal_double (obj, &v);
3972 if (SWIG_IsOK(res)) {
3973 if ((v < -FLT_MAX || v > FLT_MAX)) {
3974 return SWIG_OverflowError;
3975 } else {
3976 if (val) *val = static_cast< float >(v);
3977 }
3978 }
3979 return res;
3980 }
3981
3982
3983 SWIGINTERNINLINE PyObject *
3984 SWIG_From_float (float value)
3985 {
3986 return SWIG_From_double (value);
3987 }
3988
3989 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3990 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3991 if (data) {
3992 Py_INCREF(data->m_obj);
3993 return data->m_obj;
3994 } else {
3995 Py_INCREF(Py_None);
3996 return Py_None;
3997 }
3998 }
3999 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4000 wxPyUserData* data = NULL;
4001 if ( userData ) {
4002 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4003 data = new wxPyUserData(userData);
4004 wxPyEndBlockThreads(blocked);
4005 }
4006 self->SetUserData(data);
4007 }
4008
4009 // Figure out the type of the sizer item
4010
4011 struct wxPySizerItemInfo {
4012 wxPySizerItemInfo()
4013 : window(NULL), sizer(NULL), gotSize(false),
4014 size(wxDefaultSize), gotPos(false), pos(-1)
4015 {}
4016
4017 wxWindow* window;
4018 wxSizer* sizer;
4019 bool gotSize;
4020 wxSize size;
4021 bool gotPos;
4022 int pos;
4023 };
4024
4025 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4026
4027 wxPySizerItemInfo info;
4028 wxSize size;
4029 wxSize* sizePtr = &size;
4030
4031 // Find out what the type of the item is
4032 // try wxWindow
4033 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4034 PyErr_Clear();
4035 info.window = NULL;
4036
4037 // try wxSizer
4038 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4039 PyErr_Clear();
4040 info.sizer = NULL;
4041
4042 // try wxSize or (w,h)
4043 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4044 info.size = *sizePtr;
4045 info.gotSize = true;
4046 }
4047
4048 // or a single int
4049 if (checkIdx && PyInt_Check(item)) {
4050 info.pos = PyInt_AsLong(item);
4051 info.gotPos = true;
4052 }
4053 }
4054 }
4055
4056 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4057 // no expected type, figure out what kind of error message to generate
4058 if ( !checkSize && !checkIdx )
4059 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4060 else if ( checkSize && !checkIdx )
4061 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4062 else if ( !checkSize && checkIdx)
4063 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4064 else
4065 // can this one happen?
4066 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4067 }
4068
4069 return info;
4070 }
4071
4072 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4073 if (!self->GetClientObject())
4074 self->SetClientObject(new wxPyOORClientData(_self));
4075 }
4076 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4077
4078 wxPyUserData* data = NULL;
4079 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4080 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4081 if ( userData && (info.window || info.sizer || info.gotSize) )
4082 data = new wxPyUserData(userData);
4083 if ( info.sizer )
4084 PyObject_SetAttrString(item,"thisown",Py_False);
4085 wxPyEndBlockThreads(blocked);
4086
4087 // Now call the real Add method if a valid item type was found
4088 if ( info.window )
4089 return self->Add(info.window, proportion, flag, border, data);
4090 else if ( info.sizer )
4091 return self->Add(info.sizer, proportion, flag, border, data);
4092 else if (info.gotSize)
4093 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4094 proportion, flag, border, data);
4095 else
4096 return NULL;
4097 }
4098 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4099
4100 wxPyUserData* data = NULL;
4101 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4102 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4103 if ( userData && (info.window || info.sizer || info.gotSize) )
4104 data = new wxPyUserData(userData);
4105 if ( info.sizer )
4106 PyObject_SetAttrString(item,"thisown",Py_False);
4107 wxPyEndBlockThreads(blocked);
4108
4109 // Now call the real Insert method if a valid item type was found
4110 if ( info.window )
4111 return self->Insert(before, info.window, proportion, flag, border, data);
4112 else if ( info.sizer )
4113 return self->Insert(before, info.sizer, proportion, flag, border, data);
4114 else if (info.gotSize)
4115 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4116 proportion, flag, border, data);
4117 else
4118 return NULL;
4119 }
4120 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4121
4122 wxPyUserData* data = NULL;
4123 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4124 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4125 if ( userData && (info.window || info.sizer || info.gotSize) )
4126 data = new wxPyUserData(userData);
4127 if ( info.sizer )
4128 PyObject_SetAttrString(item,"thisown",Py_False);
4129 wxPyEndBlockThreads(blocked);
4130
4131 // Now call the real Prepend method if a valid item type was found
4132 if ( info.window )
4133 return self->Prepend(info.window, proportion, flag, border, data);
4134 else if ( info.sizer )
4135 return self->Prepend(info.sizer, proportion, flag, border, data);
4136 else if (info.gotSize)
4137 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4138 proportion, flag, border, data);
4139 else
4140 return NULL;
4141 }
4142 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4143 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4144 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4145 wxPyEndBlockThreads(blocked);
4146 if ( info.window )
4147 return self->Remove(info.window);
4148 else if ( info.sizer )
4149 return self->Remove(info.sizer);
4150 else if ( info.gotPos )
4151 return self->Remove(info.pos);
4152 else
4153 return false;
4154 }
4155 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4156 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4157 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4158 wxPyEndBlockThreads(blocked);
4159 if ( info.window )
4160 return self->Detach(info.window);
4161 else if ( info.sizer )
4162 return self->Detach(info.sizer);
4163 else if ( info.gotPos )
4164 return self->Detach(info.pos);
4165 else
4166 return false;
4167 }
4168 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4169 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4170 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4171 wxPyEndBlockThreads(blocked);
4172 if ( info.window )
4173 return self->GetItem(info.window);
4174 else if ( info.sizer )
4175 return self->GetItem(info.sizer);
4176 else if ( info.gotPos )
4177 return self->GetItem(info.pos);
4178 else
4179 return NULL;
4180 }
4181 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4182 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4183 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4184 wxPyEndBlockThreads(blocked);
4185 if ( info.window )
4186 self->SetItemMinSize(info.window, size);
4187 else if ( info.sizer )
4188 self->SetItemMinSize(info.sizer, size);
4189 else if ( info.gotPos )
4190 self->SetItemMinSize(info.pos, size);
4191 }
4192 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4193 wxSizerItemList& list = self->GetChildren();
4194 return wxPy_ConvertList(&list);
4195 }
4196 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4197 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4198 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4199 wxPyEndBlockThreads(blocked);
4200 if ( info.window )
4201 return self->Show(info.window, show, recursive);
4202 else if ( info.sizer )
4203 return self->Show(info.sizer, show, recursive);
4204 else if ( info.gotPos )
4205 return self->Show(info.pos, show);
4206 else
4207 return false;
4208 }
4209 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4210 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4211 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4212 wxPyEndBlockThreads(blocked);
4213 if ( info.window )
4214 return self->IsShown(info.window);
4215 else if ( info.sizer )
4216 return self->IsShown(info.sizer);
4217 else if ( info.gotPos )
4218 return self->IsShown(info.pos);
4219 else
4220 return false;
4221 }
4222
4223 // See pyclasses.h
4224 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4225 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4226 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4227
4228
4229
4230
4231 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4232 {
4233 if (source == Py_None) {
4234 **obj = wxGBPosition(-1,-1);
4235 return true;
4236 }
4237 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4238 }
4239
4240 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4241 {
4242 if (source == Py_None) {
4243 **obj = wxGBSpan(-1,-1);
4244 return true;
4245 }
4246 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4247 }
4248
4249
4250 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4251 wxGBPosition temp, *obj = &temp;
4252 if ( other == Py_None ) return false;
4253 if ( ! wxGBPosition_helper(other, &obj) ) {
4254 PyErr_Clear();
4255 return false;
4256 }
4257 return self->operator==(*obj);
4258 }
4259 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4260 wxGBPosition temp, *obj = &temp;
4261 if ( other == Py_None ) return true;
4262 if ( ! wxGBPosition_helper(other, &obj)) {
4263 PyErr_Clear();
4264 return true;
4265 }
4266 return self->operator!=(*obj);
4267 }
4268 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4269 self->SetRow(row);
4270 self->SetCol(col);
4271 }
4272 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4273 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4274 PyObject* tup = PyTuple_New(2);
4275 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4276 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4277 wxPyEndBlockThreads(blocked);
4278 return tup;
4279 }
4280 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4281 wxGBSpan temp, *obj = &temp;
4282 if ( other == Py_None ) return false;
4283 if ( ! wxGBSpan_helper(other, &obj) ) {
4284 PyErr_Clear();
4285 return false;
4286 }
4287 return self->operator==(*obj);
4288 }
4289 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4290 wxGBSpan temp, *obj = &temp;
4291 if ( other == Py_None ) return true;
4292 if ( ! wxGBSpan_helper(other, &obj)) {
4293 PyErr_Clear();
4294 return true;
4295 }
4296 return self->operator!=(*obj);
4297 }
4298 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4299 self->SetRowspan(rowspan);
4300 self->SetColspan(colspan);
4301 }
4302 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4303 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4304 PyObject* tup = PyTuple_New(2);
4305 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4306 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4307 wxPyEndBlockThreads(blocked);
4308 return tup;
4309 }
4310 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,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(window, pos, span, flag, border, data);
4318 }
4319 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,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(sizer, pos, span, flag, border, data);
4327 }
4328 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4329 wxPyUserData* data = NULL;
4330 if ( userData ) {
4331 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4332 data = new wxPyUserData(userData);
4333 wxPyEndBlockThreads(blocked);
4334 }
4335 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4336 }
4337 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4338 int row, col;
4339 self->GetEndPos(row, col);
4340 return wxGBPosition(row, col);
4341 }
4342 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4343
4344 wxPyUserData* data = NULL;
4345 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4346 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4347 if ( userData && (info.window || info.sizer || info.gotSize) )
4348 data = new wxPyUserData(userData);
4349 if ( info.sizer )
4350 PyObject_SetAttrString(item,"thisown",Py_False);
4351 wxPyEndBlockThreads(blocked);
4352
4353 // Now call the real Add method if a valid item type was found
4354 if ( info.window )
4355 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4356 else if ( info.sizer )
4357 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4358 else if (info.gotSize)
4359 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4360 pos, span, flag, border, data);
4361 return NULL;
4362 }
4363
4364
4365 #ifdef __cplusplus
4366 extern "C" {
4367 #endif
4368 SWIGINTERN int EmptyString_set(PyObject *) {
4369 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4370 return 1;
4371 }
4372
4373
4374 SWIGINTERN PyObject *EmptyString_get(void) {
4375 PyObject *pyobj = 0;
4376
4377 {
4378 #if wxUSE_UNICODE
4379 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4380 #else
4381 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4382 #endif
4383 }
4384 return pyobj;
4385 }
4386
4387
4388 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4389 PyObject *resultobj = 0;
4390 wxObject *arg1 = (wxObject *) 0 ;
4391 wxString result;
4392 void *argp1 = 0 ;
4393 int res1 = 0 ;
4394 PyObject *swig_obj[1] ;
4395
4396 if (!args) SWIG_fail;
4397 swig_obj[0] = args;
4398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4399 if (!SWIG_IsOK(res1)) {
4400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4401 }
4402 arg1 = reinterpret_cast< wxObject * >(argp1);
4403 {
4404 PyThreadState* __tstate = wxPyBeginAllowThreads();
4405 result = wxObject_GetClassName(arg1);
4406 wxPyEndAllowThreads(__tstate);
4407 if (PyErr_Occurred()) SWIG_fail;
4408 }
4409 {
4410 #if wxUSE_UNICODE
4411 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4412 #else
4413 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4414 #endif
4415 }
4416 return resultobj;
4417 fail:
4418 return NULL;
4419 }
4420
4421
4422 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4423 PyObject *resultobj = 0;
4424 wxObject *arg1 = (wxObject *) 0 ;
4425 void *argp1 = 0 ;
4426 int res1 = 0 ;
4427 PyObject *swig_obj[1] ;
4428
4429 if (!args) SWIG_fail;
4430 swig_obj[0] = args;
4431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4432 if (!SWIG_IsOK(res1)) {
4433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4434 }
4435 arg1 = reinterpret_cast< wxObject * >(argp1);
4436 {
4437 PyThreadState* __tstate = wxPyBeginAllowThreads();
4438 wxObject_Destroy(arg1);
4439 wxPyEndAllowThreads(__tstate);
4440 if (PyErr_Occurred()) SWIG_fail;
4441 }
4442 resultobj = SWIG_Py_Void();
4443 return resultobj;
4444 fail:
4445 return NULL;
4446 }
4447
4448
4449 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4450 PyObject *obj;
4451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4452 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4453 return SWIG_Py_Void();
4454 }
4455
4456 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4457 PyObject *resultobj = 0;
4458 wxSize *arg1 = (wxSize *) 0 ;
4459 int arg2 ;
4460 void *argp1 = 0 ;
4461 int res1 = 0 ;
4462 int val2 ;
4463 int ecode2 = 0 ;
4464 PyObject *swig_obj[2] ;
4465
4466 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4468 if (!SWIG_IsOK(res1)) {
4469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4470 }
4471 arg1 = reinterpret_cast< wxSize * >(argp1);
4472 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4473 if (!SWIG_IsOK(ecode2)) {
4474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4475 }
4476 arg2 = static_cast< int >(val2);
4477 if (arg1) (arg1)->x = arg2;
4478
4479 resultobj = SWIG_Py_Void();
4480 return resultobj;
4481 fail:
4482 return NULL;
4483 }
4484
4485
4486 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4487 PyObject *resultobj = 0;
4488 wxSize *arg1 = (wxSize *) 0 ;
4489 int result;
4490 void *argp1 = 0 ;
4491 int res1 = 0 ;
4492 PyObject *swig_obj[1] ;
4493
4494 if (!args) SWIG_fail;
4495 swig_obj[0] = args;
4496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4497 if (!SWIG_IsOK(res1)) {
4498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4499 }
4500 arg1 = reinterpret_cast< wxSize * >(argp1);
4501 result = (int) ((arg1)->x);
4502 resultobj = SWIG_From_int(static_cast< int >(result));
4503 return resultobj;
4504 fail:
4505 return NULL;
4506 }
4507
4508
4509 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4510 PyObject *resultobj = 0;
4511 wxSize *arg1 = (wxSize *) 0 ;
4512 int arg2 ;
4513 void *argp1 = 0 ;
4514 int res1 = 0 ;
4515 int val2 ;
4516 int ecode2 = 0 ;
4517 PyObject *swig_obj[2] ;
4518
4519 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4521 if (!SWIG_IsOK(res1)) {
4522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4523 }
4524 arg1 = reinterpret_cast< wxSize * >(argp1);
4525 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4526 if (!SWIG_IsOK(ecode2)) {
4527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4528 }
4529 arg2 = static_cast< int >(val2);
4530 if (arg1) (arg1)->y = arg2;
4531
4532 resultobj = SWIG_Py_Void();
4533 return resultobj;
4534 fail:
4535 return NULL;
4536 }
4537
4538
4539 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4540 PyObject *resultobj = 0;
4541 wxSize *arg1 = (wxSize *) 0 ;
4542 int result;
4543 void *argp1 = 0 ;
4544 int res1 = 0 ;
4545 PyObject *swig_obj[1] ;
4546
4547 if (!args) SWIG_fail;
4548 swig_obj[0] = args;
4549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4550 if (!SWIG_IsOK(res1)) {
4551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4552 }
4553 arg1 = reinterpret_cast< wxSize * >(argp1);
4554 result = (int) ((arg1)->y);
4555 resultobj = SWIG_From_int(static_cast< int >(result));
4556 return resultobj;
4557 fail:
4558 return NULL;
4559 }
4560
4561
4562 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4563 PyObject *resultobj = 0;
4564 int arg1 = (int) 0 ;
4565 int arg2 = (int) 0 ;
4566 wxSize *result = 0 ;
4567 int val1 ;
4568 int ecode1 = 0 ;
4569 int val2 ;
4570 int ecode2 = 0 ;
4571 PyObject * obj0 = 0 ;
4572 PyObject * obj1 = 0 ;
4573 char * kwnames[] = {
4574 (char *) "w",(char *) "h", NULL
4575 };
4576
4577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4578 if (obj0) {
4579 ecode1 = SWIG_AsVal_int(obj0, &val1);
4580 if (!SWIG_IsOK(ecode1)) {
4581 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4582 }
4583 arg1 = static_cast< int >(val1);
4584 }
4585 if (obj1) {
4586 ecode2 = SWIG_AsVal_int(obj1, &val2);
4587 if (!SWIG_IsOK(ecode2)) {
4588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4589 }
4590 arg2 = static_cast< int >(val2);
4591 }
4592 {
4593 PyThreadState* __tstate = wxPyBeginAllowThreads();
4594 result = (wxSize *)new wxSize(arg1,arg2);
4595 wxPyEndAllowThreads(__tstate);
4596 if (PyErr_Occurred()) SWIG_fail;
4597 }
4598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4599 return resultobj;
4600 fail:
4601 return NULL;
4602 }
4603
4604
4605 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4606 PyObject *resultobj = 0;
4607 wxSize *arg1 = (wxSize *) 0 ;
4608 void *argp1 = 0 ;
4609 int res1 = 0 ;
4610 PyObject *swig_obj[1] ;
4611
4612 if (!args) SWIG_fail;
4613 swig_obj[0] = args;
4614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4615 if (!SWIG_IsOK(res1)) {
4616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4617 }
4618 arg1 = reinterpret_cast< wxSize * >(argp1);
4619 {
4620 PyThreadState* __tstate = wxPyBeginAllowThreads();
4621 delete arg1;
4622
4623 wxPyEndAllowThreads(__tstate);
4624 if (PyErr_Occurred()) SWIG_fail;
4625 }
4626 resultobj = SWIG_Py_Void();
4627 return resultobj;
4628 fail:
4629 return NULL;
4630 }
4631
4632
4633 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4634 PyObject *resultobj = 0;
4635 wxSize *arg1 = (wxSize *) 0 ;
4636 PyObject *arg2 = (PyObject *) 0 ;
4637 bool result;
4638 void *argp1 = 0 ;
4639 int res1 = 0 ;
4640 PyObject * obj0 = 0 ;
4641 PyObject * obj1 = 0 ;
4642 char * kwnames[] = {
4643 (char *) "self",(char *) "other", NULL
4644 };
4645
4646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4648 if (!SWIG_IsOK(res1)) {
4649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4650 }
4651 arg1 = reinterpret_cast< wxSize * >(argp1);
4652 arg2 = obj1;
4653 {
4654 result = (bool)wxSize___eq__(arg1,arg2);
4655 if (PyErr_Occurred()) SWIG_fail;
4656 }
4657 {
4658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4659 }
4660 return resultobj;
4661 fail:
4662 return NULL;
4663 }
4664
4665
4666 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4667 PyObject *resultobj = 0;
4668 wxSize *arg1 = (wxSize *) 0 ;
4669 PyObject *arg2 = (PyObject *) 0 ;
4670 bool result;
4671 void *argp1 = 0 ;
4672 int res1 = 0 ;
4673 PyObject * obj0 = 0 ;
4674 PyObject * obj1 = 0 ;
4675 char * kwnames[] = {
4676 (char *) "self",(char *) "other", NULL
4677 };
4678
4679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4681 if (!SWIG_IsOK(res1)) {
4682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4683 }
4684 arg1 = reinterpret_cast< wxSize * >(argp1);
4685 arg2 = obj1;
4686 {
4687 result = (bool)wxSize___ne__(arg1,arg2);
4688 if (PyErr_Occurred()) SWIG_fail;
4689 }
4690 {
4691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4692 }
4693 return resultobj;
4694 fail:
4695 return NULL;
4696 }
4697
4698
4699 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4700 PyObject *resultobj = 0;
4701 wxSize *arg1 = (wxSize *) 0 ;
4702 wxSize *arg2 = 0 ;
4703 wxSize result;
4704 void *argp1 = 0 ;
4705 int res1 = 0 ;
4706 wxSize temp2 ;
4707 PyObject * obj0 = 0 ;
4708 PyObject * obj1 = 0 ;
4709 char * kwnames[] = {
4710 (char *) "self",(char *) "sz", NULL
4711 };
4712
4713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4715 if (!SWIG_IsOK(res1)) {
4716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4717 }
4718 arg1 = reinterpret_cast< wxSize * >(argp1);
4719 {
4720 arg2 = &temp2;
4721 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4722 }
4723 {
4724 PyThreadState* __tstate = wxPyBeginAllowThreads();
4725 result = (arg1)->operator +((wxSize const &)*arg2);
4726 wxPyEndAllowThreads(__tstate);
4727 if (PyErr_Occurred()) SWIG_fail;
4728 }
4729 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4730 return resultobj;
4731 fail:
4732 return NULL;
4733 }
4734
4735
4736 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4737 PyObject *resultobj = 0;
4738 wxSize *arg1 = (wxSize *) 0 ;
4739 wxSize *arg2 = 0 ;
4740 wxSize result;
4741 void *argp1 = 0 ;
4742 int res1 = 0 ;
4743 wxSize temp2 ;
4744 PyObject * obj0 = 0 ;
4745 PyObject * obj1 = 0 ;
4746 char * kwnames[] = {
4747 (char *) "self",(char *) "sz", NULL
4748 };
4749
4750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4752 if (!SWIG_IsOK(res1)) {
4753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4754 }
4755 arg1 = reinterpret_cast< wxSize * >(argp1);
4756 {
4757 arg2 = &temp2;
4758 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4759 }
4760 {
4761 PyThreadState* __tstate = wxPyBeginAllowThreads();
4762 result = (arg1)->operator -((wxSize const &)*arg2);
4763 wxPyEndAllowThreads(__tstate);
4764 if (PyErr_Occurred()) SWIG_fail;
4765 }
4766 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4767 return resultobj;
4768 fail:
4769 return NULL;
4770 }
4771
4772
4773 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4774 PyObject *resultobj = 0;
4775 wxSize *arg1 = (wxSize *) 0 ;
4776 wxSize *arg2 = 0 ;
4777 void *argp1 = 0 ;
4778 int res1 = 0 ;
4779 wxSize temp2 ;
4780 PyObject * obj0 = 0 ;
4781 PyObject * obj1 = 0 ;
4782 char * kwnames[] = {
4783 (char *) "self",(char *) "sz", NULL
4784 };
4785
4786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4788 if (!SWIG_IsOK(res1)) {
4789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4790 }
4791 arg1 = reinterpret_cast< wxSize * >(argp1);
4792 {
4793 arg2 = &temp2;
4794 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4795 }
4796 {
4797 PyThreadState* __tstate = wxPyBeginAllowThreads();
4798 (arg1)->IncTo((wxSize const &)*arg2);
4799 wxPyEndAllowThreads(__tstate);
4800 if (PyErr_Occurred()) SWIG_fail;
4801 }
4802 resultobj = SWIG_Py_Void();
4803 return resultobj;
4804 fail:
4805 return NULL;
4806 }
4807
4808
4809 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4810 PyObject *resultobj = 0;
4811 wxSize *arg1 = (wxSize *) 0 ;
4812 wxSize *arg2 = 0 ;
4813 void *argp1 = 0 ;
4814 int res1 = 0 ;
4815 wxSize temp2 ;
4816 PyObject * obj0 = 0 ;
4817 PyObject * obj1 = 0 ;
4818 char * kwnames[] = {
4819 (char *) "self",(char *) "sz", NULL
4820 };
4821
4822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4824 if (!SWIG_IsOK(res1)) {
4825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4826 }
4827 arg1 = reinterpret_cast< wxSize * >(argp1);
4828 {
4829 arg2 = &temp2;
4830 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4831 }
4832 {
4833 PyThreadState* __tstate = wxPyBeginAllowThreads();
4834 (arg1)->DecTo((wxSize const &)*arg2);
4835 wxPyEndAllowThreads(__tstate);
4836 if (PyErr_Occurred()) SWIG_fail;
4837 }
4838 resultobj = SWIG_Py_Void();
4839 return resultobj;
4840 fail:
4841 return NULL;
4842 }
4843
4844
4845 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4846 PyObject *resultobj = 0;
4847 wxSize *arg1 = (wxSize *) 0 ;
4848 int arg2 ;
4849 int arg3 ;
4850 void *argp1 = 0 ;
4851 int res1 = 0 ;
4852 int val2 ;
4853 int ecode2 = 0 ;
4854 int val3 ;
4855 int ecode3 = 0 ;
4856 PyObject * obj0 = 0 ;
4857 PyObject * obj1 = 0 ;
4858 PyObject * obj2 = 0 ;
4859 char * kwnames[] = {
4860 (char *) "self",(char *) "w",(char *) "h", NULL
4861 };
4862
4863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4865 if (!SWIG_IsOK(res1)) {
4866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4867 }
4868 arg1 = reinterpret_cast< wxSize * >(argp1);
4869 ecode2 = SWIG_AsVal_int(obj1, &val2);
4870 if (!SWIG_IsOK(ecode2)) {
4871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4872 }
4873 arg2 = static_cast< int >(val2);
4874 ecode3 = SWIG_AsVal_int(obj2, &val3);
4875 if (!SWIG_IsOK(ecode3)) {
4876 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4877 }
4878 arg3 = static_cast< int >(val3);
4879 {
4880 PyThreadState* __tstate = wxPyBeginAllowThreads();
4881 (arg1)->Set(arg2,arg3);
4882 wxPyEndAllowThreads(__tstate);
4883 if (PyErr_Occurred()) SWIG_fail;
4884 }
4885 resultobj = SWIG_Py_Void();
4886 return resultobj;
4887 fail:
4888 return NULL;
4889 }
4890
4891
4892 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4893 PyObject *resultobj = 0;
4894 wxSize *arg1 = (wxSize *) 0 ;
4895 int arg2 ;
4896 void *argp1 = 0 ;
4897 int res1 = 0 ;
4898 int val2 ;
4899 int ecode2 = 0 ;
4900 PyObject * obj0 = 0 ;
4901 PyObject * obj1 = 0 ;
4902 char * kwnames[] = {
4903 (char *) "self",(char *) "w", NULL
4904 };
4905
4906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4908 if (!SWIG_IsOK(res1)) {
4909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4910 }
4911 arg1 = reinterpret_cast< wxSize * >(argp1);
4912 ecode2 = SWIG_AsVal_int(obj1, &val2);
4913 if (!SWIG_IsOK(ecode2)) {
4914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4915 }
4916 arg2 = static_cast< int >(val2);
4917 {
4918 PyThreadState* __tstate = wxPyBeginAllowThreads();
4919 (arg1)->SetWidth(arg2);
4920 wxPyEndAllowThreads(__tstate);
4921 if (PyErr_Occurred()) SWIG_fail;
4922 }
4923 resultobj = SWIG_Py_Void();
4924 return resultobj;
4925 fail:
4926 return NULL;
4927 }
4928
4929
4930 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4931 PyObject *resultobj = 0;
4932 wxSize *arg1 = (wxSize *) 0 ;
4933 int arg2 ;
4934 void *argp1 = 0 ;
4935 int res1 = 0 ;
4936 int val2 ;
4937 int ecode2 = 0 ;
4938 PyObject * obj0 = 0 ;
4939 PyObject * obj1 = 0 ;
4940 char * kwnames[] = {
4941 (char *) "self",(char *) "h", NULL
4942 };
4943
4944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4946 if (!SWIG_IsOK(res1)) {
4947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4948 }
4949 arg1 = reinterpret_cast< wxSize * >(argp1);
4950 ecode2 = SWIG_AsVal_int(obj1, &val2);
4951 if (!SWIG_IsOK(ecode2)) {
4952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4953 }
4954 arg2 = static_cast< int >(val2);
4955 {
4956 PyThreadState* __tstate = wxPyBeginAllowThreads();
4957 (arg1)->SetHeight(arg2);
4958 wxPyEndAllowThreads(__tstate);
4959 if (PyErr_Occurred()) SWIG_fail;
4960 }
4961 resultobj = SWIG_Py_Void();
4962 return resultobj;
4963 fail:
4964 return NULL;
4965 }
4966
4967
4968 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4969 PyObject *resultobj = 0;
4970 wxSize *arg1 = (wxSize *) 0 ;
4971 int result;
4972 void *argp1 = 0 ;
4973 int res1 = 0 ;
4974 PyObject *swig_obj[1] ;
4975
4976 if (!args) SWIG_fail;
4977 swig_obj[0] = args;
4978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4979 if (!SWIG_IsOK(res1)) {
4980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4981 }
4982 arg1 = reinterpret_cast< wxSize * >(argp1);
4983 {
4984 PyThreadState* __tstate = wxPyBeginAllowThreads();
4985 result = (int)((wxSize const *)arg1)->GetWidth();
4986 wxPyEndAllowThreads(__tstate);
4987 if (PyErr_Occurred()) SWIG_fail;
4988 }
4989 resultobj = SWIG_From_int(static_cast< int >(result));
4990 return resultobj;
4991 fail:
4992 return NULL;
4993 }
4994
4995
4996 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4997 PyObject *resultobj = 0;
4998 wxSize *arg1 = (wxSize *) 0 ;
4999 int result;
5000 void *argp1 = 0 ;
5001 int res1 = 0 ;
5002 PyObject *swig_obj[1] ;
5003
5004 if (!args) SWIG_fail;
5005 swig_obj[0] = args;
5006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5007 if (!SWIG_IsOK(res1)) {
5008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5009 }
5010 arg1 = reinterpret_cast< wxSize * >(argp1);
5011 {
5012 PyThreadState* __tstate = wxPyBeginAllowThreads();
5013 result = (int)((wxSize const *)arg1)->GetHeight();
5014 wxPyEndAllowThreads(__tstate);
5015 if (PyErr_Occurred()) SWIG_fail;
5016 }
5017 resultobj = SWIG_From_int(static_cast< int >(result));
5018 return resultobj;
5019 fail:
5020 return NULL;
5021 }
5022
5023
5024 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5025 PyObject *resultobj = 0;
5026 wxSize *arg1 = (wxSize *) 0 ;
5027 bool result;
5028 void *argp1 = 0 ;
5029 int res1 = 0 ;
5030 PyObject *swig_obj[1] ;
5031
5032 if (!args) SWIG_fail;
5033 swig_obj[0] = args;
5034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5035 if (!SWIG_IsOK(res1)) {
5036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5037 }
5038 arg1 = reinterpret_cast< wxSize * >(argp1);
5039 {
5040 PyThreadState* __tstate = wxPyBeginAllowThreads();
5041 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5042 wxPyEndAllowThreads(__tstate);
5043 if (PyErr_Occurred()) SWIG_fail;
5044 }
5045 {
5046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5047 }
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5055 PyObject *resultobj = 0;
5056 wxSize *arg1 = (wxSize *) 0 ;
5057 wxSize *arg2 = 0 ;
5058 void *argp1 = 0 ;
5059 int res1 = 0 ;
5060 wxSize temp2 ;
5061 PyObject * obj0 = 0 ;
5062 PyObject * obj1 = 0 ;
5063 char * kwnames[] = {
5064 (char *) "self",(char *) "size", NULL
5065 };
5066
5067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5069 if (!SWIG_IsOK(res1)) {
5070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5071 }
5072 arg1 = reinterpret_cast< wxSize * >(argp1);
5073 {
5074 arg2 = &temp2;
5075 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5076 }
5077 {
5078 PyThreadState* __tstate = wxPyBeginAllowThreads();
5079 (arg1)->SetDefaults((wxSize const &)*arg2);
5080 wxPyEndAllowThreads(__tstate);
5081 if (PyErr_Occurred()) SWIG_fail;
5082 }
5083 resultobj = SWIG_Py_Void();
5084 return resultobj;
5085 fail:
5086 return NULL;
5087 }
5088
5089
5090 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5091 PyObject *resultobj = 0;
5092 wxSize *arg1 = (wxSize *) 0 ;
5093 PyObject *result = 0 ;
5094 void *argp1 = 0 ;
5095 int res1 = 0 ;
5096 PyObject *swig_obj[1] ;
5097
5098 if (!args) SWIG_fail;
5099 swig_obj[0] = args;
5100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5101 if (!SWIG_IsOK(res1)) {
5102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5103 }
5104 arg1 = reinterpret_cast< wxSize * >(argp1);
5105 {
5106 PyThreadState* __tstate = wxPyBeginAllowThreads();
5107 result = (PyObject *)wxSize_Get(arg1);
5108 wxPyEndAllowThreads(__tstate);
5109 if (PyErr_Occurred()) SWIG_fail;
5110 }
5111 resultobj = result;
5112 return resultobj;
5113 fail:
5114 return NULL;
5115 }
5116
5117
5118 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5119 PyObject *obj;
5120 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5121 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5122 return SWIG_Py_Void();
5123 }
5124
5125 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5126 return SWIG_Python_InitShadowInstance(args);
5127 }
5128
5129 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5130 PyObject *resultobj = 0;
5131 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5132 double arg2 ;
5133 void *argp1 = 0 ;
5134 int res1 = 0 ;
5135 double val2 ;
5136 int ecode2 = 0 ;
5137 PyObject *swig_obj[2] ;
5138
5139 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5141 if (!SWIG_IsOK(res1)) {
5142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5143 }
5144 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5145 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5146 if (!SWIG_IsOK(ecode2)) {
5147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5148 }
5149 arg2 = static_cast< double >(val2);
5150 if (arg1) (arg1)->x = arg2;
5151
5152 resultobj = SWIG_Py_Void();
5153 return resultobj;
5154 fail:
5155 return NULL;
5156 }
5157
5158
5159 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5160 PyObject *resultobj = 0;
5161 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5162 double result;
5163 void *argp1 = 0 ;
5164 int res1 = 0 ;
5165 PyObject *swig_obj[1] ;
5166
5167 if (!args) SWIG_fail;
5168 swig_obj[0] = args;
5169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5170 if (!SWIG_IsOK(res1)) {
5171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5172 }
5173 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5174 result = (double) ((arg1)->x);
5175 resultobj = SWIG_From_double(static_cast< double >(result));
5176 return resultobj;
5177 fail:
5178 return NULL;
5179 }
5180
5181
5182 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5183 PyObject *resultobj = 0;
5184 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5185 double arg2 ;
5186 void *argp1 = 0 ;
5187 int res1 = 0 ;
5188 double val2 ;
5189 int ecode2 = 0 ;
5190 PyObject *swig_obj[2] ;
5191
5192 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5194 if (!SWIG_IsOK(res1)) {
5195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5196 }
5197 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5198 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5199 if (!SWIG_IsOK(ecode2)) {
5200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5201 }
5202 arg2 = static_cast< double >(val2);
5203 if (arg1) (arg1)->y = arg2;
5204
5205 resultobj = SWIG_Py_Void();
5206 return resultobj;
5207 fail:
5208 return NULL;
5209 }
5210
5211
5212 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5213 PyObject *resultobj = 0;
5214 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5215 double result;
5216 void *argp1 = 0 ;
5217 int res1 = 0 ;
5218 PyObject *swig_obj[1] ;
5219
5220 if (!args) SWIG_fail;
5221 swig_obj[0] = args;
5222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5223 if (!SWIG_IsOK(res1)) {
5224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5225 }
5226 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5227 result = (double) ((arg1)->y);
5228 resultobj = SWIG_From_double(static_cast< double >(result));
5229 return resultobj;
5230 fail:
5231 return NULL;
5232 }
5233
5234
5235 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5236 PyObject *resultobj = 0;
5237 double arg1 = (double) 0.0 ;
5238 double arg2 = (double) 0.0 ;
5239 wxRealPoint *result = 0 ;
5240 double val1 ;
5241 int ecode1 = 0 ;
5242 double val2 ;
5243 int ecode2 = 0 ;
5244 PyObject * obj0 = 0 ;
5245 PyObject * obj1 = 0 ;
5246 char * kwnames[] = {
5247 (char *) "x",(char *) "y", NULL
5248 };
5249
5250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5251 if (obj0) {
5252 ecode1 = SWIG_AsVal_double(obj0, &val1);
5253 if (!SWIG_IsOK(ecode1)) {
5254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5255 }
5256 arg1 = static_cast< double >(val1);
5257 }
5258 if (obj1) {
5259 ecode2 = SWIG_AsVal_double(obj1, &val2);
5260 if (!SWIG_IsOK(ecode2)) {
5261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5262 }
5263 arg2 = static_cast< double >(val2);
5264 }
5265 {
5266 PyThreadState* __tstate = wxPyBeginAllowThreads();
5267 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5268 wxPyEndAllowThreads(__tstate);
5269 if (PyErr_Occurred()) SWIG_fail;
5270 }
5271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5272 return resultobj;
5273 fail:
5274 return NULL;
5275 }
5276
5277
5278 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5279 PyObject *resultobj = 0;
5280 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5281 void *argp1 = 0 ;
5282 int res1 = 0 ;
5283 PyObject *swig_obj[1] ;
5284
5285 if (!args) SWIG_fail;
5286 swig_obj[0] = args;
5287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5288 if (!SWIG_IsOK(res1)) {
5289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5290 }
5291 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5292 {
5293 PyThreadState* __tstate = wxPyBeginAllowThreads();
5294 delete arg1;
5295
5296 wxPyEndAllowThreads(__tstate);
5297 if (PyErr_Occurred()) SWIG_fail;
5298 }
5299 resultobj = SWIG_Py_Void();
5300 return resultobj;
5301 fail:
5302 return NULL;
5303 }
5304
5305
5306 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5307 PyObject *resultobj = 0;
5308 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5309 PyObject *arg2 = (PyObject *) 0 ;
5310 bool result;
5311 void *argp1 = 0 ;
5312 int res1 = 0 ;
5313 PyObject * obj0 = 0 ;
5314 PyObject * obj1 = 0 ;
5315 char * kwnames[] = {
5316 (char *) "self",(char *) "other", NULL
5317 };
5318
5319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5321 if (!SWIG_IsOK(res1)) {
5322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5323 }
5324 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5325 arg2 = obj1;
5326 {
5327 result = (bool)wxRealPoint___eq__(arg1,arg2);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 {
5331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5332 }
5333 return resultobj;
5334 fail:
5335 return NULL;
5336 }
5337
5338
5339 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5340 PyObject *resultobj = 0;
5341 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5342 PyObject *arg2 = (PyObject *) 0 ;
5343 bool result;
5344 void *argp1 = 0 ;
5345 int res1 = 0 ;
5346 PyObject * obj0 = 0 ;
5347 PyObject * obj1 = 0 ;
5348 char * kwnames[] = {
5349 (char *) "self",(char *) "other", NULL
5350 };
5351
5352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5354 if (!SWIG_IsOK(res1)) {
5355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5356 }
5357 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5358 arg2 = obj1;
5359 {
5360 result = (bool)wxRealPoint___ne__(arg1,arg2);
5361 if (PyErr_Occurred()) SWIG_fail;
5362 }
5363 {
5364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5365 }
5366 return resultobj;
5367 fail:
5368 return NULL;
5369 }
5370
5371
5372 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5373 PyObject *resultobj = 0;
5374 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5375 wxRealPoint *arg2 = 0 ;
5376 wxRealPoint result;
5377 void *argp1 = 0 ;
5378 int res1 = 0 ;
5379 wxRealPoint temp2 ;
5380 PyObject * obj0 = 0 ;
5381 PyObject * obj1 = 0 ;
5382 char * kwnames[] = {
5383 (char *) "self",(char *) "pt", NULL
5384 };
5385
5386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5388 if (!SWIG_IsOK(res1)) {
5389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5390 }
5391 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5392 {
5393 arg2 = &temp2;
5394 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5395 }
5396 {
5397 PyThreadState* __tstate = wxPyBeginAllowThreads();
5398 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5399 wxPyEndAllowThreads(__tstate);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5403 return resultobj;
5404 fail:
5405 return NULL;
5406 }
5407
5408
5409 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5410 PyObject *resultobj = 0;
5411 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5412 wxRealPoint *arg2 = 0 ;
5413 wxRealPoint result;
5414 void *argp1 = 0 ;
5415 int res1 = 0 ;
5416 wxRealPoint temp2 ;
5417 PyObject * obj0 = 0 ;
5418 PyObject * obj1 = 0 ;
5419 char * kwnames[] = {
5420 (char *) "self",(char *) "pt", NULL
5421 };
5422
5423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5425 if (!SWIG_IsOK(res1)) {
5426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5427 }
5428 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5429 {
5430 arg2 = &temp2;
5431 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5432 }
5433 {
5434 PyThreadState* __tstate = wxPyBeginAllowThreads();
5435 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5440 return resultobj;
5441 fail:
5442 return NULL;
5443 }
5444
5445
5446 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5447 PyObject *resultobj = 0;
5448 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5449 double arg2 ;
5450 double arg3 ;
5451 void *argp1 = 0 ;
5452 int res1 = 0 ;
5453 double val2 ;
5454 int ecode2 = 0 ;
5455 double val3 ;
5456 int ecode3 = 0 ;
5457 PyObject * obj0 = 0 ;
5458 PyObject * obj1 = 0 ;
5459 PyObject * obj2 = 0 ;
5460 char * kwnames[] = {
5461 (char *) "self",(char *) "x",(char *) "y", NULL
5462 };
5463
5464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5466 if (!SWIG_IsOK(res1)) {
5467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5468 }
5469 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5470 ecode2 = SWIG_AsVal_double(obj1, &val2);
5471 if (!SWIG_IsOK(ecode2)) {
5472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5473 }
5474 arg2 = static_cast< double >(val2);
5475 ecode3 = SWIG_AsVal_double(obj2, &val3);
5476 if (!SWIG_IsOK(ecode3)) {
5477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5478 }
5479 arg3 = static_cast< double >(val3);
5480 {
5481 PyThreadState* __tstate = wxPyBeginAllowThreads();
5482 wxRealPoint_Set(arg1,arg2,arg3);
5483 wxPyEndAllowThreads(__tstate);
5484 if (PyErr_Occurred()) SWIG_fail;
5485 }
5486 resultobj = SWIG_Py_Void();
5487 return resultobj;
5488 fail:
5489 return NULL;
5490 }
5491
5492
5493 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5494 PyObject *resultobj = 0;
5495 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5496 PyObject *result = 0 ;
5497 void *argp1 = 0 ;
5498 int res1 = 0 ;
5499 PyObject *swig_obj[1] ;
5500
5501 if (!args) SWIG_fail;
5502 swig_obj[0] = args;
5503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5504 if (!SWIG_IsOK(res1)) {
5505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5506 }
5507 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5508 {
5509 PyThreadState* __tstate = wxPyBeginAllowThreads();
5510 result = (PyObject *)wxRealPoint_Get(arg1);
5511 wxPyEndAllowThreads(__tstate);
5512 if (PyErr_Occurred()) SWIG_fail;
5513 }
5514 resultobj = result;
5515 return resultobj;
5516 fail:
5517 return NULL;
5518 }
5519
5520
5521 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5522 PyObject *obj;
5523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5524 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5525 return SWIG_Py_Void();
5526 }
5527
5528 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5529 return SWIG_Python_InitShadowInstance(args);
5530 }
5531
5532 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5533 PyObject *resultobj = 0;
5534 wxPoint *arg1 = (wxPoint *) 0 ;
5535 int arg2 ;
5536 void *argp1 = 0 ;
5537 int res1 = 0 ;
5538 int val2 ;
5539 int ecode2 = 0 ;
5540 PyObject *swig_obj[2] ;
5541
5542 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5544 if (!SWIG_IsOK(res1)) {
5545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5546 }
5547 arg1 = reinterpret_cast< wxPoint * >(argp1);
5548 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5549 if (!SWIG_IsOK(ecode2)) {
5550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5551 }
5552 arg2 = static_cast< int >(val2);
5553 if (arg1) (arg1)->x = arg2;
5554
5555 resultobj = SWIG_Py_Void();
5556 return resultobj;
5557 fail:
5558 return NULL;
5559 }
5560
5561
5562 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5563 PyObject *resultobj = 0;
5564 wxPoint *arg1 = (wxPoint *) 0 ;
5565 int result;
5566 void *argp1 = 0 ;
5567 int res1 = 0 ;
5568 PyObject *swig_obj[1] ;
5569
5570 if (!args) SWIG_fail;
5571 swig_obj[0] = args;
5572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5573 if (!SWIG_IsOK(res1)) {
5574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5575 }
5576 arg1 = reinterpret_cast< wxPoint * >(argp1);
5577 result = (int) ((arg1)->x);
5578 resultobj = SWIG_From_int(static_cast< int >(result));
5579 return resultobj;
5580 fail:
5581 return NULL;
5582 }
5583
5584
5585 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5586 PyObject *resultobj = 0;
5587 wxPoint *arg1 = (wxPoint *) 0 ;
5588 int arg2 ;
5589 void *argp1 = 0 ;
5590 int res1 = 0 ;
5591 int val2 ;
5592 int ecode2 = 0 ;
5593 PyObject *swig_obj[2] ;
5594
5595 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5597 if (!SWIG_IsOK(res1)) {
5598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5599 }
5600 arg1 = reinterpret_cast< wxPoint * >(argp1);
5601 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5602 if (!SWIG_IsOK(ecode2)) {
5603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5604 }
5605 arg2 = static_cast< int >(val2);
5606 if (arg1) (arg1)->y = arg2;
5607
5608 resultobj = SWIG_Py_Void();
5609 return resultobj;
5610 fail:
5611 return NULL;
5612 }
5613
5614
5615 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5616 PyObject *resultobj = 0;
5617 wxPoint *arg1 = (wxPoint *) 0 ;
5618 int result;
5619 void *argp1 = 0 ;
5620 int res1 = 0 ;
5621 PyObject *swig_obj[1] ;
5622
5623 if (!args) SWIG_fail;
5624 swig_obj[0] = args;
5625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5626 if (!SWIG_IsOK(res1)) {
5627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5628 }
5629 arg1 = reinterpret_cast< wxPoint * >(argp1);
5630 result = (int) ((arg1)->y);
5631 resultobj = SWIG_From_int(static_cast< int >(result));
5632 return resultobj;
5633 fail:
5634 return NULL;
5635 }
5636
5637
5638 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5639 PyObject *resultobj = 0;
5640 int arg1 = (int) 0 ;
5641 int arg2 = (int) 0 ;
5642 wxPoint *result = 0 ;
5643 int val1 ;
5644 int ecode1 = 0 ;
5645 int val2 ;
5646 int ecode2 = 0 ;
5647 PyObject * obj0 = 0 ;
5648 PyObject * obj1 = 0 ;
5649 char * kwnames[] = {
5650 (char *) "x",(char *) "y", NULL
5651 };
5652
5653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5654 if (obj0) {
5655 ecode1 = SWIG_AsVal_int(obj0, &val1);
5656 if (!SWIG_IsOK(ecode1)) {
5657 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5658 }
5659 arg1 = static_cast< int >(val1);
5660 }
5661 if (obj1) {
5662 ecode2 = SWIG_AsVal_int(obj1, &val2);
5663 if (!SWIG_IsOK(ecode2)) {
5664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5665 }
5666 arg2 = static_cast< int >(val2);
5667 }
5668 {
5669 PyThreadState* __tstate = wxPyBeginAllowThreads();
5670 result = (wxPoint *)new wxPoint(arg1,arg2);
5671 wxPyEndAllowThreads(__tstate);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5675 return resultobj;
5676 fail:
5677 return NULL;
5678 }
5679
5680
5681 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5682 PyObject *resultobj = 0;
5683 wxPoint *arg1 = (wxPoint *) 0 ;
5684 void *argp1 = 0 ;
5685 int res1 = 0 ;
5686 PyObject *swig_obj[1] ;
5687
5688 if (!args) SWIG_fail;
5689 swig_obj[0] = args;
5690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5691 if (!SWIG_IsOK(res1)) {
5692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5693 }
5694 arg1 = reinterpret_cast< wxPoint * >(argp1);
5695 {
5696 PyThreadState* __tstate = wxPyBeginAllowThreads();
5697 delete arg1;
5698
5699 wxPyEndAllowThreads(__tstate);
5700 if (PyErr_Occurred()) SWIG_fail;
5701 }
5702 resultobj = SWIG_Py_Void();
5703 return resultobj;
5704 fail:
5705 return NULL;
5706 }
5707
5708
5709 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5710 PyObject *resultobj = 0;
5711 wxPoint *arg1 = (wxPoint *) 0 ;
5712 PyObject *arg2 = (PyObject *) 0 ;
5713 bool result;
5714 void *argp1 = 0 ;
5715 int res1 = 0 ;
5716 PyObject * obj0 = 0 ;
5717 PyObject * obj1 = 0 ;
5718 char * kwnames[] = {
5719 (char *) "self",(char *) "other", NULL
5720 };
5721
5722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5724 if (!SWIG_IsOK(res1)) {
5725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5726 }
5727 arg1 = reinterpret_cast< wxPoint * >(argp1);
5728 arg2 = obj1;
5729 {
5730 result = (bool)wxPoint___eq__(arg1,arg2);
5731 if (PyErr_Occurred()) SWIG_fail;
5732 }
5733 {
5734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5735 }
5736 return resultobj;
5737 fail:
5738 return NULL;
5739 }
5740
5741
5742 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5743 PyObject *resultobj = 0;
5744 wxPoint *arg1 = (wxPoint *) 0 ;
5745 PyObject *arg2 = (PyObject *) 0 ;
5746 bool result;
5747 void *argp1 = 0 ;
5748 int res1 = 0 ;
5749 PyObject * obj0 = 0 ;
5750 PyObject * obj1 = 0 ;
5751 char * kwnames[] = {
5752 (char *) "self",(char *) "other", NULL
5753 };
5754
5755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5757 if (!SWIG_IsOK(res1)) {
5758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5759 }
5760 arg1 = reinterpret_cast< wxPoint * >(argp1);
5761 arg2 = obj1;
5762 {
5763 result = (bool)wxPoint___ne__(arg1,arg2);
5764 if (PyErr_Occurred()) SWIG_fail;
5765 }
5766 {
5767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5768 }
5769 return resultobj;
5770 fail:
5771 return NULL;
5772 }
5773
5774
5775 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5776 PyObject *resultobj = 0;
5777 wxPoint *arg1 = (wxPoint *) 0 ;
5778 wxPoint *arg2 = 0 ;
5779 wxPoint result;
5780 void *argp1 = 0 ;
5781 int res1 = 0 ;
5782 wxPoint temp2 ;
5783 PyObject * obj0 = 0 ;
5784 PyObject * obj1 = 0 ;
5785 char * kwnames[] = {
5786 (char *) "self",(char *) "pt", NULL
5787 };
5788
5789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5791 if (!SWIG_IsOK(res1)) {
5792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5793 }
5794 arg1 = reinterpret_cast< wxPoint * >(argp1);
5795 {
5796 arg2 = &temp2;
5797 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5798 }
5799 {
5800 PyThreadState* __tstate = wxPyBeginAllowThreads();
5801 result = (arg1)->operator +((wxPoint const &)*arg2);
5802 wxPyEndAllowThreads(__tstate);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5806 return resultobj;
5807 fail:
5808 return NULL;
5809 }
5810
5811
5812 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5813 PyObject *resultobj = 0;
5814 wxPoint *arg1 = (wxPoint *) 0 ;
5815 wxPoint *arg2 = 0 ;
5816 wxPoint result;
5817 void *argp1 = 0 ;
5818 int res1 = 0 ;
5819 wxPoint temp2 ;
5820 PyObject * obj0 = 0 ;
5821 PyObject * obj1 = 0 ;
5822 char * kwnames[] = {
5823 (char *) "self",(char *) "pt", NULL
5824 };
5825
5826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5828 if (!SWIG_IsOK(res1)) {
5829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5830 }
5831 arg1 = reinterpret_cast< wxPoint * >(argp1);
5832 {
5833 arg2 = &temp2;
5834 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5835 }
5836 {
5837 PyThreadState* __tstate = wxPyBeginAllowThreads();
5838 result = (arg1)->operator -((wxPoint const &)*arg2);
5839 wxPyEndAllowThreads(__tstate);
5840 if (PyErr_Occurred()) SWIG_fail;
5841 }
5842 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5843 return resultobj;
5844 fail:
5845 return NULL;
5846 }
5847
5848
5849 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5850 PyObject *resultobj = 0;
5851 wxPoint *arg1 = (wxPoint *) 0 ;
5852 wxPoint *arg2 = 0 ;
5853 wxPoint *result = 0 ;
5854 void *argp1 = 0 ;
5855 int res1 = 0 ;
5856 wxPoint temp2 ;
5857 PyObject * obj0 = 0 ;
5858 PyObject * obj1 = 0 ;
5859 char * kwnames[] = {
5860 (char *) "self",(char *) "pt", NULL
5861 };
5862
5863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5865 if (!SWIG_IsOK(res1)) {
5866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5867 }
5868 arg1 = reinterpret_cast< wxPoint * >(argp1);
5869 {
5870 arg2 = &temp2;
5871 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5872 }
5873 {
5874 PyThreadState* __tstate = wxPyBeginAllowThreads();
5875 {
5876 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5877 result = (wxPoint *) &_result_ref;
5878 }
5879 wxPyEndAllowThreads(__tstate);
5880 if (PyErr_Occurred()) SWIG_fail;
5881 }
5882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5883 return resultobj;
5884 fail:
5885 return NULL;
5886 }
5887
5888
5889 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5890 PyObject *resultobj = 0;
5891 wxPoint *arg1 = (wxPoint *) 0 ;
5892 wxPoint *arg2 = 0 ;
5893 wxPoint *result = 0 ;
5894 void *argp1 = 0 ;
5895 int res1 = 0 ;
5896 wxPoint temp2 ;
5897 PyObject * obj0 = 0 ;
5898 PyObject * obj1 = 0 ;
5899 char * kwnames[] = {
5900 (char *) "self",(char *) "pt", NULL
5901 };
5902
5903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5905 if (!SWIG_IsOK(res1)) {
5906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5907 }
5908 arg1 = reinterpret_cast< wxPoint * >(argp1);
5909 {
5910 arg2 = &temp2;
5911 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5912 }
5913 {
5914 PyThreadState* __tstate = wxPyBeginAllowThreads();
5915 {
5916 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5917 result = (wxPoint *) &_result_ref;
5918 }
5919 wxPyEndAllowThreads(__tstate);
5920 if (PyErr_Occurred()) SWIG_fail;
5921 }
5922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5923 return resultobj;
5924 fail:
5925 return NULL;
5926 }
5927
5928
5929 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5930 PyObject *resultobj = 0;
5931 wxPoint *arg1 = (wxPoint *) 0 ;
5932 long arg2 ;
5933 long arg3 ;
5934 void *argp1 = 0 ;
5935 int res1 = 0 ;
5936 long val2 ;
5937 int ecode2 = 0 ;
5938 long val3 ;
5939 int ecode3 = 0 ;
5940 PyObject * obj0 = 0 ;
5941 PyObject * obj1 = 0 ;
5942 PyObject * obj2 = 0 ;
5943 char * kwnames[] = {
5944 (char *) "self",(char *) "x",(char *) "y", NULL
5945 };
5946
5947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5949 if (!SWIG_IsOK(res1)) {
5950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5951 }
5952 arg1 = reinterpret_cast< wxPoint * >(argp1);
5953 ecode2 = SWIG_AsVal_long(obj1, &val2);
5954 if (!SWIG_IsOK(ecode2)) {
5955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5956 }
5957 arg2 = static_cast< long >(val2);
5958 ecode3 = SWIG_AsVal_long(obj2, &val3);
5959 if (!SWIG_IsOK(ecode3)) {
5960 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5961 }
5962 arg3 = static_cast< long >(val3);
5963 {
5964 PyThreadState* __tstate = wxPyBeginAllowThreads();
5965 wxPoint_Set(arg1,arg2,arg3);
5966 wxPyEndAllowThreads(__tstate);
5967 if (PyErr_Occurred()) SWIG_fail;
5968 }
5969 resultobj = SWIG_Py_Void();
5970 return resultobj;
5971 fail:
5972 return NULL;
5973 }
5974
5975
5976 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5977 PyObject *resultobj = 0;
5978 wxPoint *arg1 = (wxPoint *) 0 ;
5979 PyObject *result = 0 ;
5980 void *argp1 = 0 ;
5981 int res1 = 0 ;
5982 PyObject *swig_obj[1] ;
5983
5984 if (!args) SWIG_fail;
5985 swig_obj[0] = args;
5986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5987 if (!SWIG_IsOK(res1)) {
5988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5989 }
5990 arg1 = reinterpret_cast< wxPoint * >(argp1);
5991 {
5992 PyThreadState* __tstate = wxPyBeginAllowThreads();
5993 result = (PyObject *)wxPoint_Get(arg1);
5994 wxPyEndAllowThreads(__tstate);
5995 if (PyErr_Occurred()) SWIG_fail;
5996 }
5997 resultobj = result;
5998 return resultobj;
5999 fail:
6000 return NULL;
6001 }
6002
6003
6004 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6005 PyObject *obj;
6006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6007 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6008 return SWIG_Py_Void();
6009 }
6010
6011 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6012 return SWIG_Python_InitShadowInstance(args);
6013 }
6014
6015 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6016 PyObject *resultobj = 0;
6017 int arg1 = (int) 0 ;
6018 int arg2 = (int) 0 ;
6019 int arg3 = (int) 0 ;
6020 int arg4 = (int) 0 ;
6021 wxRect *result = 0 ;
6022 int val1 ;
6023 int ecode1 = 0 ;
6024 int val2 ;
6025 int ecode2 = 0 ;
6026 int val3 ;
6027 int ecode3 = 0 ;
6028 int val4 ;
6029 int ecode4 = 0 ;
6030 PyObject * obj0 = 0 ;
6031 PyObject * obj1 = 0 ;
6032 PyObject * obj2 = 0 ;
6033 PyObject * obj3 = 0 ;
6034 char * kwnames[] = {
6035 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6036 };
6037
6038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6039 if (obj0) {
6040 ecode1 = SWIG_AsVal_int(obj0, &val1);
6041 if (!SWIG_IsOK(ecode1)) {
6042 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6043 }
6044 arg1 = static_cast< int >(val1);
6045 }
6046 if (obj1) {
6047 ecode2 = SWIG_AsVal_int(obj1, &val2);
6048 if (!SWIG_IsOK(ecode2)) {
6049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6050 }
6051 arg2 = static_cast< int >(val2);
6052 }
6053 if (obj2) {
6054 ecode3 = SWIG_AsVal_int(obj2, &val3);
6055 if (!SWIG_IsOK(ecode3)) {
6056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6057 }
6058 arg3 = static_cast< int >(val3);
6059 }
6060 if (obj3) {
6061 ecode4 = SWIG_AsVal_int(obj3, &val4);
6062 if (!SWIG_IsOK(ecode4)) {
6063 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6064 }
6065 arg4 = static_cast< int >(val4);
6066 }
6067 {
6068 PyThreadState* __tstate = wxPyBeginAllowThreads();
6069 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6070 wxPyEndAllowThreads(__tstate);
6071 if (PyErr_Occurred()) SWIG_fail;
6072 }
6073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6074 return resultobj;
6075 fail:
6076 return NULL;
6077 }
6078
6079
6080 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6081 PyObject *resultobj = 0;
6082 wxPoint *arg1 = 0 ;
6083 wxPoint *arg2 = 0 ;
6084 wxRect *result = 0 ;
6085 wxPoint temp1 ;
6086 wxPoint temp2 ;
6087 PyObject * obj0 = 0 ;
6088 PyObject * obj1 = 0 ;
6089 char * kwnames[] = {
6090 (char *) "topLeft",(char *) "bottomRight", NULL
6091 };
6092
6093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6094 {
6095 arg1 = &temp1;
6096 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6097 }
6098 {
6099 arg2 = &temp2;
6100 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6101 }
6102 {
6103 PyThreadState* __tstate = wxPyBeginAllowThreads();
6104 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6105 wxPyEndAllowThreads(__tstate);
6106 if (PyErr_Occurred()) SWIG_fail;
6107 }
6108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6109 return resultobj;
6110 fail:
6111 return NULL;
6112 }
6113
6114
6115 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6116 PyObject *resultobj = 0;
6117 wxPoint *arg1 = 0 ;
6118 wxSize *arg2 = 0 ;
6119 wxRect *result = 0 ;
6120 wxPoint temp1 ;
6121 wxSize temp2 ;
6122 PyObject * obj0 = 0 ;
6123 PyObject * obj1 = 0 ;
6124 char * kwnames[] = {
6125 (char *) "pos",(char *) "size", NULL
6126 };
6127
6128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6129 {
6130 arg1 = &temp1;
6131 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6132 }
6133 {
6134 arg2 = &temp2;
6135 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6136 }
6137 {
6138 PyThreadState* __tstate = wxPyBeginAllowThreads();
6139 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6140 wxPyEndAllowThreads(__tstate);
6141 if (PyErr_Occurred()) SWIG_fail;
6142 }
6143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6144 return resultobj;
6145 fail:
6146 return NULL;
6147 }
6148
6149
6150 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6151 PyObject *resultobj = 0;
6152 wxSize *arg1 = 0 ;
6153 wxRect *result = 0 ;
6154 wxSize temp1 ;
6155 PyObject * obj0 = 0 ;
6156 char * kwnames[] = {
6157 (char *) "size", NULL
6158 };
6159
6160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6161 {
6162 arg1 = &temp1;
6163 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6164 }
6165 {
6166 PyThreadState* __tstate = wxPyBeginAllowThreads();
6167 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6168 wxPyEndAllowThreads(__tstate);
6169 if (PyErr_Occurred()) SWIG_fail;
6170 }
6171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6172 return resultobj;
6173 fail:
6174 return NULL;
6175 }
6176
6177
6178 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6179 PyObject *resultobj = 0;
6180 wxRect *arg1 = (wxRect *) 0 ;
6181 void *argp1 = 0 ;
6182 int res1 = 0 ;
6183 PyObject *swig_obj[1] ;
6184
6185 if (!args) SWIG_fail;
6186 swig_obj[0] = args;
6187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6188 if (!SWIG_IsOK(res1)) {
6189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6190 }
6191 arg1 = reinterpret_cast< wxRect * >(argp1);
6192 {
6193 PyThreadState* __tstate = wxPyBeginAllowThreads();
6194 delete arg1;
6195
6196 wxPyEndAllowThreads(__tstate);
6197 if (PyErr_Occurred()) SWIG_fail;
6198 }
6199 resultobj = SWIG_Py_Void();
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6207 PyObject *resultobj = 0;
6208 wxRect *arg1 = (wxRect *) 0 ;
6209 int result;
6210 void *argp1 = 0 ;
6211 int res1 = 0 ;
6212 PyObject *swig_obj[1] ;
6213
6214 if (!args) SWIG_fail;
6215 swig_obj[0] = args;
6216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6217 if (!SWIG_IsOK(res1)) {
6218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6219 }
6220 arg1 = reinterpret_cast< wxRect * >(argp1);
6221 {
6222 PyThreadState* __tstate = wxPyBeginAllowThreads();
6223 result = (int)((wxRect const *)arg1)->GetX();
6224 wxPyEndAllowThreads(__tstate);
6225 if (PyErr_Occurred()) SWIG_fail;
6226 }
6227 resultobj = SWIG_From_int(static_cast< int >(result));
6228 return resultobj;
6229 fail:
6230 return NULL;
6231 }
6232
6233
6234 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6235 PyObject *resultobj = 0;
6236 wxRect *arg1 = (wxRect *) 0 ;
6237 int arg2 ;
6238 void *argp1 = 0 ;
6239 int res1 = 0 ;
6240 int val2 ;
6241 int ecode2 = 0 ;
6242 PyObject * obj0 = 0 ;
6243 PyObject * obj1 = 0 ;
6244 char * kwnames[] = {
6245 (char *) "self",(char *) "x", NULL
6246 };
6247
6248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6250 if (!SWIG_IsOK(res1)) {
6251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6252 }
6253 arg1 = reinterpret_cast< wxRect * >(argp1);
6254 ecode2 = SWIG_AsVal_int(obj1, &val2);
6255 if (!SWIG_IsOK(ecode2)) {
6256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6257 }
6258 arg2 = static_cast< int >(val2);
6259 {
6260 PyThreadState* __tstate = wxPyBeginAllowThreads();
6261 (arg1)->SetX(arg2);
6262 wxPyEndAllowThreads(__tstate);
6263 if (PyErr_Occurred()) SWIG_fail;
6264 }
6265 resultobj = SWIG_Py_Void();
6266 return resultobj;
6267 fail:
6268 return NULL;
6269 }
6270
6271
6272 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6273 PyObject *resultobj = 0;
6274 wxRect *arg1 = (wxRect *) 0 ;
6275 int result;
6276 void *argp1 = 0 ;
6277 int res1 = 0 ;
6278 PyObject *swig_obj[1] ;
6279
6280 if (!args) SWIG_fail;
6281 swig_obj[0] = args;
6282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6283 if (!SWIG_IsOK(res1)) {
6284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6285 }
6286 arg1 = reinterpret_cast< wxRect * >(argp1);
6287 {
6288 PyThreadState* __tstate = wxPyBeginAllowThreads();
6289 result = (int)(arg1)->GetY();
6290 wxPyEndAllowThreads(__tstate);
6291 if (PyErr_Occurred()) SWIG_fail;
6292 }
6293 resultobj = SWIG_From_int(static_cast< int >(result));
6294 return resultobj;
6295 fail:
6296 return NULL;
6297 }
6298
6299
6300 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6301 PyObject *resultobj = 0;
6302 wxRect *arg1 = (wxRect *) 0 ;
6303 int arg2 ;
6304 void *argp1 = 0 ;
6305 int res1 = 0 ;
6306 int val2 ;
6307 int ecode2 = 0 ;
6308 PyObject * obj0 = 0 ;
6309 PyObject * obj1 = 0 ;
6310 char * kwnames[] = {
6311 (char *) "self",(char *) "y", NULL
6312 };
6313
6314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6316 if (!SWIG_IsOK(res1)) {
6317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6318 }
6319 arg1 = reinterpret_cast< wxRect * >(argp1);
6320 ecode2 = SWIG_AsVal_int(obj1, &val2);
6321 if (!SWIG_IsOK(ecode2)) {
6322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6323 }
6324 arg2 = static_cast< int >(val2);
6325 {
6326 PyThreadState* __tstate = wxPyBeginAllowThreads();
6327 (arg1)->SetY(arg2);
6328 wxPyEndAllowThreads(__tstate);
6329 if (PyErr_Occurred()) SWIG_fail;
6330 }
6331 resultobj = SWIG_Py_Void();
6332 return resultobj;
6333 fail:
6334 return NULL;
6335 }
6336
6337
6338 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6339 PyObject *resultobj = 0;
6340 wxRect *arg1 = (wxRect *) 0 ;
6341 int result;
6342 void *argp1 = 0 ;
6343 int res1 = 0 ;
6344 PyObject *swig_obj[1] ;
6345
6346 if (!args) SWIG_fail;
6347 swig_obj[0] = args;
6348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6349 if (!SWIG_IsOK(res1)) {
6350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6351 }
6352 arg1 = reinterpret_cast< wxRect * >(argp1);
6353 {
6354 PyThreadState* __tstate = wxPyBeginAllowThreads();
6355 result = (int)((wxRect const *)arg1)->GetWidth();
6356 wxPyEndAllowThreads(__tstate);
6357 if (PyErr_Occurred()) SWIG_fail;
6358 }
6359 resultobj = SWIG_From_int(static_cast< int >(result));
6360 return resultobj;
6361 fail:
6362 return NULL;
6363 }
6364
6365
6366 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6367 PyObject *resultobj = 0;
6368 wxRect *arg1 = (wxRect *) 0 ;
6369 int arg2 ;
6370 void *argp1 = 0 ;
6371 int res1 = 0 ;
6372 int val2 ;
6373 int ecode2 = 0 ;
6374 PyObject * obj0 = 0 ;
6375 PyObject * obj1 = 0 ;
6376 char * kwnames[] = {
6377 (char *) "self",(char *) "w", NULL
6378 };
6379
6380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6382 if (!SWIG_IsOK(res1)) {
6383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6384 }
6385 arg1 = reinterpret_cast< wxRect * >(argp1);
6386 ecode2 = SWIG_AsVal_int(obj1, &val2);
6387 if (!SWIG_IsOK(ecode2)) {
6388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6389 }
6390 arg2 = static_cast< int >(val2);
6391 {
6392 PyThreadState* __tstate = wxPyBeginAllowThreads();
6393 (arg1)->SetWidth(arg2);
6394 wxPyEndAllowThreads(__tstate);
6395 if (PyErr_Occurred()) SWIG_fail;
6396 }
6397 resultobj = SWIG_Py_Void();
6398 return resultobj;
6399 fail:
6400 return NULL;
6401 }
6402
6403
6404 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6405 PyObject *resultobj = 0;
6406 wxRect *arg1 = (wxRect *) 0 ;
6407 int result;
6408 void *argp1 = 0 ;
6409 int res1 = 0 ;
6410 PyObject *swig_obj[1] ;
6411
6412 if (!args) SWIG_fail;
6413 swig_obj[0] = args;
6414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6415 if (!SWIG_IsOK(res1)) {
6416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6417 }
6418 arg1 = reinterpret_cast< wxRect * >(argp1);
6419 {
6420 PyThreadState* __tstate = wxPyBeginAllowThreads();
6421 result = (int)((wxRect const *)arg1)->GetHeight();
6422 wxPyEndAllowThreads(__tstate);
6423 if (PyErr_Occurred()) SWIG_fail;
6424 }
6425 resultobj = SWIG_From_int(static_cast< int >(result));
6426 return resultobj;
6427 fail:
6428 return NULL;
6429 }
6430
6431
6432 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6433 PyObject *resultobj = 0;
6434 wxRect *arg1 = (wxRect *) 0 ;
6435 int arg2 ;
6436 void *argp1 = 0 ;
6437 int res1 = 0 ;
6438 int val2 ;
6439 int ecode2 = 0 ;
6440 PyObject * obj0 = 0 ;
6441 PyObject * obj1 = 0 ;
6442 char * kwnames[] = {
6443 (char *) "self",(char *) "h", NULL
6444 };
6445
6446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6448 if (!SWIG_IsOK(res1)) {
6449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6450 }
6451 arg1 = reinterpret_cast< wxRect * >(argp1);
6452 ecode2 = SWIG_AsVal_int(obj1, &val2);
6453 if (!SWIG_IsOK(ecode2)) {
6454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6455 }
6456 arg2 = static_cast< int >(val2);
6457 {
6458 PyThreadState* __tstate = wxPyBeginAllowThreads();
6459 (arg1)->SetHeight(arg2);
6460 wxPyEndAllowThreads(__tstate);
6461 if (PyErr_Occurred()) SWIG_fail;
6462 }
6463 resultobj = SWIG_Py_Void();
6464 return resultobj;
6465 fail:
6466 return NULL;
6467 }
6468
6469
6470 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6471 PyObject *resultobj = 0;
6472 wxRect *arg1 = (wxRect *) 0 ;
6473 wxPoint result;
6474 void *argp1 = 0 ;
6475 int res1 = 0 ;
6476 PyObject *swig_obj[1] ;
6477
6478 if (!args) SWIG_fail;
6479 swig_obj[0] = args;
6480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6481 if (!SWIG_IsOK(res1)) {
6482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6483 }
6484 arg1 = reinterpret_cast< wxRect * >(argp1);
6485 {
6486 PyThreadState* __tstate = wxPyBeginAllowThreads();
6487 result = ((wxRect const *)arg1)->GetPosition();
6488 wxPyEndAllowThreads(__tstate);
6489 if (PyErr_Occurred()) SWIG_fail;
6490 }
6491 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6492 return resultobj;
6493 fail:
6494 return NULL;
6495 }
6496
6497
6498 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6499 PyObject *resultobj = 0;
6500 wxRect *arg1 = (wxRect *) 0 ;
6501 wxPoint *arg2 = 0 ;
6502 void *argp1 = 0 ;
6503 int res1 = 0 ;
6504 wxPoint temp2 ;
6505 PyObject * obj0 = 0 ;
6506 PyObject * obj1 = 0 ;
6507 char * kwnames[] = {
6508 (char *) "self",(char *) "p", NULL
6509 };
6510
6511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6513 if (!SWIG_IsOK(res1)) {
6514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6515 }
6516 arg1 = reinterpret_cast< wxRect * >(argp1);
6517 {
6518 arg2 = &temp2;
6519 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6520 }
6521 {
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 (arg1)->SetPosition((wxPoint const &)*arg2);
6524 wxPyEndAllowThreads(__tstate);
6525 if (PyErr_Occurred()) SWIG_fail;
6526 }
6527 resultobj = SWIG_Py_Void();
6528 return resultobj;
6529 fail:
6530 return NULL;
6531 }
6532
6533
6534 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6535 PyObject *resultobj = 0;
6536 wxRect *arg1 = (wxRect *) 0 ;
6537 wxSize result;
6538 void *argp1 = 0 ;
6539 int res1 = 0 ;
6540 PyObject *swig_obj[1] ;
6541
6542 if (!args) SWIG_fail;
6543 swig_obj[0] = args;
6544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6545 if (!SWIG_IsOK(res1)) {
6546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6547 }
6548 arg1 = reinterpret_cast< wxRect * >(argp1);
6549 {
6550 PyThreadState* __tstate = wxPyBeginAllowThreads();
6551 result = ((wxRect const *)arg1)->GetSize();
6552 wxPyEndAllowThreads(__tstate);
6553 if (PyErr_Occurred()) SWIG_fail;
6554 }
6555 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6556 return resultobj;
6557 fail:
6558 return NULL;
6559 }
6560
6561
6562 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6563 PyObject *resultobj = 0;
6564 wxRect *arg1 = (wxRect *) 0 ;
6565 wxSize *arg2 = 0 ;
6566 void *argp1 = 0 ;
6567 int res1 = 0 ;
6568 wxSize temp2 ;
6569 PyObject * obj0 = 0 ;
6570 PyObject * obj1 = 0 ;
6571 char * kwnames[] = {
6572 (char *) "self",(char *) "s", NULL
6573 };
6574
6575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6577 if (!SWIG_IsOK(res1)) {
6578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6579 }
6580 arg1 = reinterpret_cast< wxRect * >(argp1);
6581 {
6582 arg2 = &temp2;
6583 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6584 }
6585 {
6586 PyThreadState* __tstate = wxPyBeginAllowThreads();
6587 (arg1)->SetSize((wxSize const &)*arg2);
6588 wxPyEndAllowThreads(__tstate);
6589 if (PyErr_Occurred()) SWIG_fail;
6590 }
6591 resultobj = SWIG_Py_Void();
6592 return resultobj;
6593 fail:
6594 return NULL;
6595 }
6596
6597
6598 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6599 PyObject *resultobj = 0;
6600 wxRect *arg1 = (wxRect *) 0 ;
6601 bool result;
6602 void *argp1 = 0 ;
6603 int res1 = 0 ;
6604 PyObject *swig_obj[1] ;
6605
6606 if (!args) SWIG_fail;
6607 swig_obj[0] = args;
6608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6609 if (!SWIG_IsOK(res1)) {
6610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6611 }
6612 arg1 = reinterpret_cast< wxRect * >(argp1);
6613 {
6614 PyThreadState* __tstate = wxPyBeginAllowThreads();
6615 result = (bool)((wxRect const *)arg1)->IsEmpty();
6616 wxPyEndAllowThreads(__tstate);
6617 if (PyErr_Occurred()) SWIG_fail;
6618 }
6619 {
6620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6621 }
6622 return resultobj;
6623 fail:
6624 return NULL;
6625 }
6626
6627
6628 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6629 PyObject *resultobj = 0;
6630 wxRect *arg1 = (wxRect *) 0 ;
6631 wxPoint result;
6632 void *argp1 = 0 ;
6633 int res1 = 0 ;
6634 PyObject *swig_obj[1] ;
6635
6636 if (!args) SWIG_fail;
6637 swig_obj[0] = args;
6638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6639 if (!SWIG_IsOK(res1)) {
6640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6641 }
6642 arg1 = reinterpret_cast< wxRect * >(argp1);
6643 {
6644 PyThreadState* __tstate = wxPyBeginAllowThreads();
6645 result = ((wxRect const *)arg1)->GetTopLeft();
6646 wxPyEndAllowThreads(__tstate);
6647 if (PyErr_Occurred()) SWIG_fail;
6648 }
6649 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6650 return resultobj;
6651 fail:
6652 return NULL;
6653 }
6654
6655
6656 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6657 PyObject *resultobj = 0;
6658 wxRect *arg1 = (wxRect *) 0 ;
6659 wxPoint *arg2 = 0 ;
6660 void *argp1 = 0 ;
6661 int res1 = 0 ;
6662 wxPoint temp2 ;
6663 PyObject * obj0 = 0 ;
6664 PyObject * obj1 = 0 ;
6665 char * kwnames[] = {
6666 (char *) "self",(char *) "p", NULL
6667 };
6668
6669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6671 if (!SWIG_IsOK(res1)) {
6672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6673 }
6674 arg1 = reinterpret_cast< wxRect * >(argp1);
6675 {
6676 arg2 = &temp2;
6677 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6678 }
6679 {
6680 PyThreadState* __tstate = wxPyBeginAllowThreads();
6681 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6682 wxPyEndAllowThreads(__tstate);
6683 if (PyErr_Occurred()) SWIG_fail;
6684 }
6685 resultobj = SWIG_Py_Void();
6686 return resultobj;
6687 fail:
6688 return NULL;
6689 }
6690
6691
6692 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6693 PyObject *resultobj = 0;
6694 wxRect *arg1 = (wxRect *) 0 ;
6695 wxPoint result;
6696 void *argp1 = 0 ;
6697 int res1 = 0 ;
6698 PyObject *swig_obj[1] ;
6699
6700 if (!args) SWIG_fail;
6701 swig_obj[0] = args;
6702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6703 if (!SWIG_IsOK(res1)) {
6704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6705 }
6706 arg1 = reinterpret_cast< wxRect * >(argp1);
6707 {
6708 PyThreadState* __tstate = wxPyBeginAllowThreads();
6709 result = ((wxRect const *)arg1)->GetBottomRight();
6710 wxPyEndAllowThreads(__tstate);
6711 if (PyErr_Occurred()) SWIG_fail;
6712 }
6713 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6714 return resultobj;
6715 fail:
6716 return NULL;
6717 }
6718
6719
6720 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6721 PyObject *resultobj = 0;
6722 wxRect *arg1 = (wxRect *) 0 ;
6723 wxPoint *arg2 = 0 ;
6724 void *argp1 = 0 ;
6725 int res1 = 0 ;
6726 wxPoint temp2 ;
6727 PyObject * obj0 = 0 ;
6728 PyObject * obj1 = 0 ;
6729 char * kwnames[] = {
6730 (char *) "self",(char *) "p", NULL
6731 };
6732
6733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6735 if (!SWIG_IsOK(res1)) {
6736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6737 }
6738 arg1 = reinterpret_cast< wxRect * >(argp1);
6739 {
6740 arg2 = &temp2;
6741 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6742 }
6743 {
6744 PyThreadState* __tstate = wxPyBeginAllowThreads();
6745 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6746 wxPyEndAllowThreads(__tstate);
6747 if (PyErr_Occurred()) SWIG_fail;
6748 }
6749 resultobj = SWIG_Py_Void();
6750 return resultobj;
6751 fail:
6752 return NULL;
6753 }
6754
6755
6756 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6757 PyObject *resultobj = 0;
6758 wxRect *arg1 = (wxRect *) 0 ;
6759 int result;
6760 void *argp1 = 0 ;
6761 int res1 = 0 ;
6762 PyObject *swig_obj[1] ;
6763
6764 if (!args) SWIG_fail;
6765 swig_obj[0] = args;
6766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6767 if (!SWIG_IsOK(res1)) {
6768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6769 }
6770 arg1 = reinterpret_cast< wxRect * >(argp1);
6771 {
6772 PyThreadState* __tstate = wxPyBeginAllowThreads();
6773 result = (int)((wxRect const *)arg1)->GetLeft();
6774 wxPyEndAllowThreads(__tstate);
6775 if (PyErr_Occurred()) SWIG_fail;
6776 }
6777 resultobj = SWIG_From_int(static_cast< int >(result));
6778 return resultobj;
6779 fail:
6780 return NULL;
6781 }
6782
6783
6784 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6785 PyObject *resultobj = 0;
6786 wxRect *arg1 = (wxRect *) 0 ;
6787 int result;
6788 void *argp1 = 0 ;
6789 int res1 = 0 ;
6790 PyObject *swig_obj[1] ;
6791
6792 if (!args) SWIG_fail;
6793 swig_obj[0] = args;
6794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6795 if (!SWIG_IsOK(res1)) {
6796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6797 }
6798 arg1 = reinterpret_cast< wxRect * >(argp1);
6799 {
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 result = (int)((wxRect const *)arg1)->GetTop();
6802 wxPyEndAllowThreads(__tstate);
6803 if (PyErr_Occurred()) SWIG_fail;
6804 }
6805 resultobj = SWIG_From_int(static_cast< int >(result));
6806 return resultobj;
6807 fail:
6808 return NULL;
6809 }
6810
6811
6812 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6813 PyObject *resultobj = 0;
6814 wxRect *arg1 = (wxRect *) 0 ;
6815 int result;
6816 void *argp1 = 0 ;
6817 int res1 = 0 ;
6818 PyObject *swig_obj[1] ;
6819
6820 if (!args) SWIG_fail;
6821 swig_obj[0] = args;
6822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6823 if (!SWIG_IsOK(res1)) {
6824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6825 }
6826 arg1 = reinterpret_cast< wxRect * >(argp1);
6827 {
6828 PyThreadState* __tstate = wxPyBeginAllowThreads();
6829 result = (int)((wxRect const *)arg1)->GetBottom();
6830 wxPyEndAllowThreads(__tstate);
6831 if (PyErr_Occurred()) SWIG_fail;
6832 }
6833 resultobj = SWIG_From_int(static_cast< int >(result));
6834 return resultobj;
6835 fail:
6836 return NULL;
6837 }
6838
6839
6840 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6841 PyObject *resultobj = 0;
6842 wxRect *arg1 = (wxRect *) 0 ;
6843 int result;
6844 void *argp1 = 0 ;
6845 int res1 = 0 ;
6846 PyObject *swig_obj[1] ;
6847
6848 if (!args) SWIG_fail;
6849 swig_obj[0] = args;
6850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6851 if (!SWIG_IsOK(res1)) {
6852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6853 }
6854 arg1 = reinterpret_cast< wxRect * >(argp1);
6855 {
6856 PyThreadState* __tstate = wxPyBeginAllowThreads();
6857 result = (int)((wxRect const *)arg1)->GetRight();
6858 wxPyEndAllowThreads(__tstate);
6859 if (PyErr_Occurred()) SWIG_fail;
6860 }
6861 resultobj = SWIG_From_int(static_cast< int >(result));
6862 return resultobj;
6863 fail:
6864 return NULL;
6865 }
6866
6867
6868 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6869 PyObject *resultobj = 0;
6870 wxRect *arg1 = (wxRect *) 0 ;
6871 int arg2 ;
6872 void *argp1 = 0 ;
6873 int res1 = 0 ;
6874 int val2 ;
6875 int ecode2 = 0 ;
6876 PyObject * obj0 = 0 ;
6877 PyObject * obj1 = 0 ;
6878 char * kwnames[] = {
6879 (char *) "self",(char *) "left", NULL
6880 };
6881
6882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6884 if (!SWIG_IsOK(res1)) {
6885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6886 }
6887 arg1 = reinterpret_cast< wxRect * >(argp1);
6888 ecode2 = SWIG_AsVal_int(obj1, &val2);
6889 if (!SWIG_IsOK(ecode2)) {
6890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6891 }
6892 arg2 = static_cast< int >(val2);
6893 {
6894 PyThreadState* __tstate = wxPyBeginAllowThreads();
6895 (arg1)->SetLeft(arg2);
6896 wxPyEndAllowThreads(__tstate);
6897 if (PyErr_Occurred()) SWIG_fail;
6898 }
6899 resultobj = SWIG_Py_Void();
6900 return resultobj;
6901 fail:
6902 return NULL;
6903 }
6904
6905
6906 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6907 PyObject *resultobj = 0;
6908 wxRect *arg1 = (wxRect *) 0 ;
6909 int arg2 ;
6910 void *argp1 = 0 ;
6911 int res1 = 0 ;
6912 int val2 ;
6913 int ecode2 = 0 ;
6914 PyObject * obj0 = 0 ;
6915 PyObject * obj1 = 0 ;
6916 char * kwnames[] = {
6917 (char *) "self",(char *) "right", NULL
6918 };
6919
6920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6922 if (!SWIG_IsOK(res1)) {
6923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6924 }
6925 arg1 = reinterpret_cast< wxRect * >(argp1);
6926 ecode2 = SWIG_AsVal_int(obj1, &val2);
6927 if (!SWIG_IsOK(ecode2)) {
6928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6929 }
6930 arg2 = static_cast< int >(val2);
6931 {
6932 PyThreadState* __tstate = wxPyBeginAllowThreads();
6933 (arg1)->SetRight(arg2);
6934 wxPyEndAllowThreads(__tstate);
6935 if (PyErr_Occurred()) SWIG_fail;
6936 }
6937 resultobj = SWIG_Py_Void();
6938 return resultobj;
6939 fail:
6940 return NULL;
6941 }
6942
6943
6944 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6945 PyObject *resultobj = 0;
6946 wxRect *arg1 = (wxRect *) 0 ;
6947 int arg2 ;
6948 void *argp1 = 0 ;
6949 int res1 = 0 ;
6950 int val2 ;
6951 int ecode2 = 0 ;
6952 PyObject * obj0 = 0 ;
6953 PyObject * obj1 = 0 ;
6954 char * kwnames[] = {
6955 (char *) "self",(char *) "top", NULL
6956 };
6957
6958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6960 if (!SWIG_IsOK(res1)) {
6961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6962 }
6963 arg1 = reinterpret_cast< wxRect * >(argp1);
6964 ecode2 = SWIG_AsVal_int(obj1, &val2);
6965 if (!SWIG_IsOK(ecode2)) {
6966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6967 }
6968 arg2 = static_cast< int >(val2);
6969 {
6970 PyThreadState* __tstate = wxPyBeginAllowThreads();
6971 (arg1)->SetTop(arg2);
6972 wxPyEndAllowThreads(__tstate);
6973 if (PyErr_Occurred()) SWIG_fail;
6974 }
6975 resultobj = SWIG_Py_Void();
6976 return resultobj;
6977 fail:
6978 return NULL;
6979 }
6980
6981
6982 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6983 PyObject *resultobj = 0;
6984 wxRect *arg1 = (wxRect *) 0 ;
6985 int arg2 ;
6986 void *argp1 = 0 ;
6987 int res1 = 0 ;
6988 int val2 ;
6989 int ecode2 = 0 ;
6990 PyObject * obj0 = 0 ;
6991 PyObject * obj1 = 0 ;
6992 char * kwnames[] = {
6993 (char *) "self",(char *) "bottom", NULL
6994 };
6995
6996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6998 if (!SWIG_IsOK(res1)) {
6999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7000 }
7001 arg1 = reinterpret_cast< wxRect * >(argp1);
7002 ecode2 = SWIG_AsVal_int(obj1, &val2);
7003 if (!SWIG_IsOK(ecode2)) {
7004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7005 }
7006 arg2 = static_cast< int >(val2);
7007 {
7008 PyThreadState* __tstate = wxPyBeginAllowThreads();
7009 (arg1)->SetBottom(arg2);
7010 wxPyEndAllowThreads(__tstate);
7011 if (PyErr_Occurred()) SWIG_fail;
7012 }
7013 resultobj = SWIG_Py_Void();
7014 return resultobj;
7015 fail:
7016 return NULL;
7017 }
7018
7019
7020 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7021 PyObject *resultobj = 0;
7022 wxRect *arg1 = (wxRect *) 0 ;
7023 int arg2 ;
7024 int arg3 ;
7025 wxRect *result = 0 ;
7026 void *argp1 = 0 ;
7027 int res1 = 0 ;
7028 int val2 ;
7029 int ecode2 = 0 ;
7030 int val3 ;
7031 int ecode3 = 0 ;
7032 PyObject * obj0 = 0 ;
7033 PyObject * obj1 = 0 ;
7034 PyObject * obj2 = 0 ;
7035 char * kwnames[] = {
7036 (char *) "self",(char *) "dx",(char *) "dy", NULL
7037 };
7038
7039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7041 if (!SWIG_IsOK(res1)) {
7042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7043 }
7044 arg1 = reinterpret_cast< wxRect * >(argp1);
7045 ecode2 = SWIG_AsVal_int(obj1, &val2);
7046 if (!SWIG_IsOK(ecode2)) {
7047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7048 }
7049 arg2 = static_cast< int >(val2);
7050 ecode3 = SWIG_AsVal_int(obj2, &val3);
7051 if (!SWIG_IsOK(ecode3)) {
7052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7053 }
7054 arg3 = static_cast< int >(val3);
7055 {
7056 PyThreadState* __tstate = wxPyBeginAllowThreads();
7057 {
7058 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7059 result = (wxRect *) &_result_ref;
7060 }
7061 wxPyEndAllowThreads(__tstate);
7062 if (PyErr_Occurred()) SWIG_fail;
7063 }
7064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7065 return resultobj;
7066 fail:
7067 return NULL;
7068 }
7069
7070
7071 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7072 PyObject *resultobj = 0;
7073 wxRect *arg1 = (wxRect *) 0 ;
7074 int arg2 ;
7075 int arg3 ;
7076 wxRect *result = 0 ;
7077 void *argp1 = 0 ;
7078 int res1 = 0 ;
7079 int val2 ;
7080 int ecode2 = 0 ;
7081 int val3 ;
7082 int ecode3 = 0 ;
7083 PyObject * obj0 = 0 ;
7084 PyObject * obj1 = 0 ;
7085 PyObject * obj2 = 0 ;
7086 char * kwnames[] = {
7087 (char *) "self",(char *) "dx",(char *) "dy", NULL
7088 };
7089
7090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7092 if (!SWIG_IsOK(res1)) {
7093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7094 }
7095 arg1 = reinterpret_cast< wxRect * >(argp1);
7096 ecode2 = SWIG_AsVal_int(obj1, &val2);
7097 if (!SWIG_IsOK(ecode2)) {
7098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7099 }
7100 arg2 = static_cast< int >(val2);
7101 ecode3 = SWIG_AsVal_int(obj2, &val3);
7102 if (!SWIG_IsOK(ecode3)) {
7103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7104 }
7105 arg3 = static_cast< int >(val3);
7106 {
7107 PyThreadState* __tstate = wxPyBeginAllowThreads();
7108 {
7109 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7110 result = (wxRect *) &_result_ref;
7111 }
7112 wxPyEndAllowThreads(__tstate);
7113 if (PyErr_Occurred()) SWIG_fail;
7114 }
7115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7116 return resultobj;
7117 fail:
7118 return NULL;
7119 }
7120
7121
7122 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7123 PyObject *resultobj = 0;
7124 wxRect *arg1 = (wxRect *) 0 ;
7125 int arg2 ;
7126 int arg3 ;
7127 void *argp1 = 0 ;
7128 int res1 = 0 ;
7129 int val2 ;
7130 int ecode2 = 0 ;
7131 int val3 ;
7132 int ecode3 = 0 ;
7133 PyObject * obj0 = 0 ;
7134 PyObject * obj1 = 0 ;
7135 PyObject * obj2 = 0 ;
7136 char * kwnames[] = {
7137 (char *) "self",(char *) "dx",(char *) "dy", NULL
7138 };
7139
7140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7142 if (!SWIG_IsOK(res1)) {
7143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7144 }
7145 arg1 = reinterpret_cast< wxRect * >(argp1);
7146 ecode2 = SWIG_AsVal_int(obj1, &val2);
7147 if (!SWIG_IsOK(ecode2)) {
7148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7149 }
7150 arg2 = static_cast< int >(val2);
7151 ecode3 = SWIG_AsVal_int(obj2, &val3);
7152 if (!SWIG_IsOK(ecode3)) {
7153 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7154 }
7155 arg3 = static_cast< int >(val3);
7156 {
7157 PyThreadState* __tstate = wxPyBeginAllowThreads();
7158 (arg1)->Offset(arg2,arg3);
7159 wxPyEndAllowThreads(__tstate);
7160 if (PyErr_Occurred()) SWIG_fail;
7161 }
7162 resultobj = SWIG_Py_Void();
7163 return resultobj;
7164 fail:
7165 return NULL;
7166 }
7167
7168
7169 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7170 PyObject *resultobj = 0;
7171 wxRect *arg1 = (wxRect *) 0 ;
7172 wxPoint *arg2 = 0 ;
7173 void *argp1 = 0 ;
7174 int res1 = 0 ;
7175 wxPoint temp2 ;
7176 PyObject * obj0 = 0 ;
7177 PyObject * obj1 = 0 ;
7178 char * kwnames[] = {
7179 (char *) "self",(char *) "pt", NULL
7180 };
7181
7182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7184 if (!SWIG_IsOK(res1)) {
7185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7186 }
7187 arg1 = reinterpret_cast< wxRect * >(argp1);
7188 {
7189 arg2 = &temp2;
7190 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7191 }
7192 {
7193 PyThreadState* __tstate = wxPyBeginAllowThreads();
7194 (arg1)->Offset((wxPoint const &)*arg2);
7195 wxPyEndAllowThreads(__tstate);
7196 if (PyErr_Occurred()) SWIG_fail;
7197 }
7198 resultobj = SWIG_Py_Void();
7199 return resultobj;
7200 fail:
7201 return NULL;
7202 }
7203
7204
7205 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7206 PyObject *resultobj = 0;
7207 wxRect *arg1 = (wxRect *) 0 ;
7208 wxRect *arg2 = 0 ;
7209 wxRect result;
7210 void *argp1 = 0 ;
7211 int res1 = 0 ;
7212 wxRect temp2 ;
7213 PyObject * obj0 = 0 ;
7214 PyObject * obj1 = 0 ;
7215 char * kwnames[] = {
7216 (char *) "self",(char *) "rect", NULL
7217 };
7218
7219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7221 if (!SWIG_IsOK(res1)) {
7222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7223 }
7224 arg1 = reinterpret_cast< wxRect * >(argp1);
7225 {
7226 arg2 = &temp2;
7227 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7228 }
7229 {
7230 PyThreadState* __tstate = wxPyBeginAllowThreads();
7231 result = (arg1)->Intersect((wxRect const &)*arg2);
7232 wxPyEndAllowThreads(__tstate);
7233 if (PyErr_Occurred()) SWIG_fail;
7234 }
7235 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7236 return resultobj;
7237 fail:
7238 return NULL;
7239 }
7240
7241
7242 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7243 PyObject *resultobj = 0;
7244 wxRect *arg1 = (wxRect *) 0 ;
7245 wxRect *arg2 = 0 ;
7246 wxRect result;
7247 void *argp1 = 0 ;
7248 int res1 = 0 ;
7249 wxRect temp2 ;
7250 PyObject * obj0 = 0 ;
7251 PyObject * obj1 = 0 ;
7252 char * kwnames[] = {
7253 (char *) "self",(char *) "rect", NULL
7254 };
7255
7256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7258 if (!SWIG_IsOK(res1)) {
7259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7260 }
7261 arg1 = reinterpret_cast< wxRect * >(argp1);
7262 {
7263 arg2 = &temp2;
7264 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7265 }
7266 {
7267 PyThreadState* __tstate = wxPyBeginAllowThreads();
7268 result = (arg1)->Union((wxRect const &)*arg2);
7269 wxPyEndAllowThreads(__tstate);
7270 if (PyErr_Occurred()) SWIG_fail;
7271 }
7272 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7273 return resultobj;
7274 fail:
7275 return NULL;
7276 }
7277
7278
7279 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7280 PyObject *resultobj = 0;
7281 wxRect *arg1 = (wxRect *) 0 ;
7282 wxRect *arg2 = 0 ;
7283 wxRect result;
7284 void *argp1 = 0 ;
7285 int res1 = 0 ;
7286 wxRect temp2 ;
7287 PyObject * obj0 = 0 ;
7288 PyObject * obj1 = 0 ;
7289 char * kwnames[] = {
7290 (char *) "self",(char *) "rect", NULL
7291 };
7292
7293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7295 if (!SWIG_IsOK(res1)) {
7296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7297 }
7298 arg1 = reinterpret_cast< wxRect * >(argp1);
7299 {
7300 arg2 = &temp2;
7301 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7302 }
7303 {
7304 PyThreadState* __tstate = wxPyBeginAllowThreads();
7305 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7306 wxPyEndAllowThreads(__tstate);
7307 if (PyErr_Occurred()) SWIG_fail;
7308 }
7309 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7310 return resultobj;
7311 fail:
7312 return NULL;
7313 }
7314
7315
7316 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7317 PyObject *resultobj = 0;
7318 wxRect *arg1 = (wxRect *) 0 ;
7319 wxRect *arg2 = 0 ;
7320 wxRect *result = 0 ;
7321 void *argp1 = 0 ;
7322 int res1 = 0 ;
7323 wxRect temp2 ;
7324 PyObject * obj0 = 0 ;
7325 PyObject * obj1 = 0 ;
7326 char * kwnames[] = {
7327 (char *) "self",(char *) "rect", NULL
7328 };
7329
7330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7332 if (!SWIG_IsOK(res1)) {
7333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7334 }
7335 arg1 = reinterpret_cast< wxRect * >(argp1);
7336 {
7337 arg2 = &temp2;
7338 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7339 }
7340 {
7341 PyThreadState* __tstate = wxPyBeginAllowThreads();
7342 {
7343 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7344 result = (wxRect *) &_result_ref;
7345 }
7346 wxPyEndAllowThreads(__tstate);
7347 if (PyErr_Occurred()) SWIG_fail;
7348 }
7349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7350 return resultobj;
7351 fail:
7352 return NULL;
7353 }
7354
7355
7356 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7357 PyObject *resultobj = 0;
7358 wxRect *arg1 = (wxRect *) 0 ;
7359 PyObject *arg2 = (PyObject *) 0 ;
7360 bool result;
7361 void *argp1 = 0 ;
7362 int res1 = 0 ;
7363 PyObject * obj0 = 0 ;
7364 PyObject * obj1 = 0 ;
7365 char * kwnames[] = {
7366 (char *) "self",(char *) "other", NULL
7367 };
7368
7369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7371 if (!SWIG_IsOK(res1)) {
7372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7373 }
7374 arg1 = reinterpret_cast< wxRect * >(argp1);
7375 arg2 = obj1;
7376 {
7377 result = (bool)wxRect___eq__(arg1,arg2);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 {
7381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7382 }
7383 return resultobj;
7384 fail:
7385 return NULL;
7386 }
7387
7388
7389 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7390 PyObject *resultobj = 0;
7391 wxRect *arg1 = (wxRect *) 0 ;
7392 PyObject *arg2 = (PyObject *) 0 ;
7393 bool result;
7394 void *argp1 = 0 ;
7395 int res1 = 0 ;
7396 PyObject * obj0 = 0 ;
7397 PyObject * obj1 = 0 ;
7398 char * kwnames[] = {
7399 (char *) "self",(char *) "other", NULL
7400 };
7401
7402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7404 if (!SWIG_IsOK(res1)) {
7405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7406 }
7407 arg1 = reinterpret_cast< wxRect * >(argp1);
7408 arg2 = obj1;
7409 {
7410 result = (bool)wxRect___ne__(arg1,arg2);
7411 if (PyErr_Occurred()) SWIG_fail;
7412 }
7413 {
7414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7415 }
7416 return resultobj;
7417 fail:
7418 return NULL;
7419 }
7420
7421
7422 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7423 PyObject *resultobj = 0;
7424 wxRect *arg1 = (wxRect *) 0 ;
7425 int arg2 ;
7426 int arg3 ;
7427 bool result;
7428 void *argp1 = 0 ;
7429 int res1 = 0 ;
7430 int val2 ;
7431 int ecode2 = 0 ;
7432 int val3 ;
7433 int ecode3 = 0 ;
7434 PyObject * obj0 = 0 ;
7435 PyObject * obj1 = 0 ;
7436 PyObject * obj2 = 0 ;
7437 char * kwnames[] = {
7438 (char *) "self",(char *) "x",(char *) "y", NULL
7439 };
7440
7441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7443 if (!SWIG_IsOK(res1)) {
7444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7445 }
7446 arg1 = reinterpret_cast< wxRect * >(argp1);
7447 ecode2 = SWIG_AsVal_int(obj1, &val2);
7448 if (!SWIG_IsOK(ecode2)) {
7449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7450 }
7451 arg2 = static_cast< int >(val2);
7452 ecode3 = SWIG_AsVal_int(obj2, &val3);
7453 if (!SWIG_IsOK(ecode3)) {
7454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7455 }
7456 arg3 = static_cast< int >(val3);
7457 {
7458 PyThreadState* __tstate = wxPyBeginAllowThreads();
7459 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7460 wxPyEndAllowThreads(__tstate);
7461 if (PyErr_Occurred()) SWIG_fail;
7462 }
7463 {
7464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7465 }
7466 return resultobj;
7467 fail:
7468 return NULL;
7469 }
7470
7471
7472 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7473 PyObject *resultobj = 0;
7474 wxRect *arg1 = (wxRect *) 0 ;
7475 wxPoint *arg2 = 0 ;
7476 bool result;
7477 void *argp1 = 0 ;
7478 int res1 = 0 ;
7479 wxPoint temp2 ;
7480 PyObject * obj0 = 0 ;
7481 PyObject * obj1 = 0 ;
7482 char * kwnames[] = {
7483 (char *) "self",(char *) "pt", NULL
7484 };
7485
7486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7488 if (!SWIG_IsOK(res1)) {
7489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7490 }
7491 arg1 = reinterpret_cast< wxRect * >(argp1);
7492 {
7493 arg2 = &temp2;
7494 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7495 }
7496 {
7497 PyThreadState* __tstate = wxPyBeginAllowThreads();
7498 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7499 wxPyEndAllowThreads(__tstate);
7500 if (PyErr_Occurred()) SWIG_fail;
7501 }
7502 {
7503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7504 }
7505 return resultobj;
7506 fail:
7507 return NULL;
7508 }
7509
7510
7511 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7512 PyObject *resultobj = 0;
7513 wxRect *arg1 = (wxRect *) 0 ;
7514 wxRect *arg2 = 0 ;
7515 bool result;
7516 void *argp1 = 0 ;
7517 int res1 = 0 ;
7518 wxRect temp2 ;
7519 PyObject * obj0 = 0 ;
7520 PyObject * obj1 = 0 ;
7521 char * kwnames[] = {
7522 (char *) "self",(char *) "rect", NULL
7523 };
7524
7525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7527 if (!SWIG_IsOK(res1)) {
7528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7529 }
7530 arg1 = reinterpret_cast< wxRect * >(argp1);
7531 {
7532 arg2 = &temp2;
7533 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7534 }
7535 {
7536 PyThreadState* __tstate = wxPyBeginAllowThreads();
7537 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7538 wxPyEndAllowThreads(__tstate);
7539 if (PyErr_Occurred()) SWIG_fail;
7540 }
7541 {
7542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7543 }
7544 return resultobj;
7545 fail:
7546 return NULL;
7547 }
7548
7549
7550 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7551 PyObject *resultobj = 0;
7552 wxRect *arg1 = (wxRect *) 0 ;
7553 wxRect *arg2 = 0 ;
7554 int arg3 = (int) wxBOTH ;
7555 wxRect result;
7556 void *argp1 = 0 ;
7557 int res1 = 0 ;
7558 wxRect temp2 ;
7559 int val3 ;
7560 int ecode3 = 0 ;
7561 PyObject * obj0 = 0 ;
7562 PyObject * obj1 = 0 ;
7563 PyObject * obj2 = 0 ;
7564 char * kwnames[] = {
7565 (char *) "self",(char *) "r",(char *) "dir", NULL
7566 };
7567
7568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7570 if (!SWIG_IsOK(res1)) {
7571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7572 }
7573 arg1 = reinterpret_cast< wxRect * >(argp1);
7574 {
7575 arg2 = &temp2;
7576 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7577 }
7578 if (obj2) {
7579 ecode3 = SWIG_AsVal_int(obj2, &val3);
7580 if (!SWIG_IsOK(ecode3)) {
7581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7582 }
7583 arg3 = static_cast< int >(val3);
7584 }
7585 {
7586 PyThreadState* __tstate = wxPyBeginAllowThreads();
7587 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7588 wxPyEndAllowThreads(__tstate);
7589 if (PyErr_Occurred()) SWIG_fail;
7590 }
7591 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7592 return resultobj;
7593 fail:
7594 return NULL;
7595 }
7596
7597
7598 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7599 PyObject *resultobj = 0;
7600 wxRect *arg1 = (wxRect *) 0 ;
7601 int arg2 ;
7602 void *argp1 = 0 ;
7603 int res1 = 0 ;
7604 int val2 ;
7605 int ecode2 = 0 ;
7606 PyObject *swig_obj[2] ;
7607
7608 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7610 if (!SWIG_IsOK(res1)) {
7611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7612 }
7613 arg1 = reinterpret_cast< wxRect * >(argp1);
7614 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7615 if (!SWIG_IsOK(ecode2)) {
7616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7617 }
7618 arg2 = static_cast< int >(val2);
7619 if (arg1) (arg1)->x = arg2;
7620
7621 resultobj = SWIG_Py_Void();
7622 return resultobj;
7623 fail:
7624 return NULL;
7625 }
7626
7627
7628 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7629 PyObject *resultobj = 0;
7630 wxRect *arg1 = (wxRect *) 0 ;
7631 int result;
7632 void *argp1 = 0 ;
7633 int res1 = 0 ;
7634 PyObject *swig_obj[1] ;
7635
7636 if (!args) SWIG_fail;
7637 swig_obj[0] = args;
7638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7639 if (!SWIG_IsOK(res1)) {
7640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7641 }
7642 arg1 = reinterpret_cast< wxRect * >(argp1);
7643 result = (int) ((arg1)->x);
7644 resultobj = SWIG_From_int(static_cast< int >(result));
7645 return resultobj;
7646 fail:
7647 return NULL;
7648 }
7649
7650
7651 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7652 PyObject *resultobj = 0;
7653 wxRect *arg1 = (wxRect *) 0 ;
7654 int arg2 ;
7655 void *argp1 = 0 ;
7656 int res1 = 0 ;
7657 int val2 ;
7658 int ecode2 = 0 ;
7659 PyObject *swig_obj[2] ;
7660
7661 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7663 if (!SWIG_IsOK(res1)) {
7664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7665 }
7666 arg1 = reinterpret_cast< wxRect * >(argp1);
7667 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7668 if (!SWIG_IsOK(ecode2)) {
7669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7670 }
7671 arg2 = static_cast< int >(val2);
7672 if (arg1) (arg1)->y = arg2;
7673
7674 resultobj = SWIG_Py_Void();
7675 return resultobj;
7676 fail:
7677 return NULL;
7678 }
7679
7680
7681 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7682 PyObject *resultobj = 0;
7683 wxRect *arg1 = (wxRect *) 0 ;
7684 int result;
7685 void *argp1 = 0 ;
7686 int res1 = 0 ;
7687 PyObject *swig_obj[1] ;
7688
7689 if (!args) SWIG_fail;
7690 swig_obj[0] = args;
7691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7692 if (!SWIG_IsOK(res1)) {
7693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7694 }
7695 arg1 = reinterpret_cast< wxRect * >(argp1);
7696 result = (int) ((arg1)->y);
7697 resultobj = SWIG_From_int(static_cast< int >(result));
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7705 PyObject *resultobj = 0;
7706 wxRect *arg1 = (wxRect *) 0 ;
7707 int arg2 ;
7708 void *argp1 = 0 ;
7709 int res1 = 0 ;
7710 int val2 ;
7711 int ecode2 = 0 ;
7712 PyObject *swig_obj[2] ;
7713
7714 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7716 if (!SWIG_IsOK(res1)) {
7717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7718 }
7719 arg1 = reinterpret_cast< wxRect * >(argp1);
7720 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7721 if (!SWIG_IsOK(ecode2)) {
7722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7723 }
7724 arg2 = static_cast< int >(val2);
7725 if (arg1) (arg1)->width = arg2;
7726
7727 resultobj = SWIG_Py_Void();
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7735 PyObject *resultobj = 0;
7736 wxRect *arg1 = (wxRect *) 0 ;
7737 int result;
7738 void *argp1 = 0 ;
7739 int res1 = 0 ;
7740 PyObject *swig_obj[1] ;
7741
7742 if (!args) SWIG_fail;
7743 swig_obj[0] = args;
7744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7745 if (!SWIG_IsOK(res1)) {
7746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7747 }
7748 arg1 = reinterpret_cast< wxRect * >(argp1);
7749 result = (int) ((arg1)->width);
7750 resultobj = SWIG_From_int(static_cast< int >(result));
7751 return resultobj;
7752 fail:
7753 return NULL;
7754 }
7755
7756
7757 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7758 PyObject *resultobj = 0;
7759 wxRect *arg1 = (wxRect *) 0 ;
7760 int arg2 ;
7761 void *argp1 = 0 ;
7762 int res1 = 0 ;
7763 int val2 ;
7764 int ecode2 = 0 ;
7765 PyObject *swig_obj[2] ;
7766
7767 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7769 if (!SWIG_IsOK(res1)) {
7770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7771 }
7772 arg1 = reinterpret_cast< wxRect * >(argp1);
7773 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7774 if (!SWIG_IsOK(ecode2)) {
7775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7776 }
7777 arg2 = static_cast< int >(val2);
7778 if (arg1) (arg1)->height = arg2;
7779
7780 resultobj = SWIG_Py_Void();
7781 return resultobj;
7782 fail:
7783 return NULL;
7784 }
7785
7786
7787 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7788 PyObject *resultobj = 0;
7789 wxRect *arg1 = (wxRect *) 0 ;
7790 int result;
7791 void *argp1 = 0 ;
7792 int res1 = 0 ;
7793 PyObject *swig_obj[1] ;
7794
7795 if (!args) SWIG_fail;
7796 swig_obj[0] = args;
7797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7798 if (!SWIG_IsOK(res1)) {
7799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7800 }
7801 arg1 = reinterpret_cast< wxRect * >(argp1);
7802 result = (int) ((arg1)->height);
7803 resultobj = SWIG_From_int(static_cast< int >(result));
7804 return resultobj;
7805 fail:
7806 return NULL;
7807 }
7808
7809
7810 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7811 PyObject *resultobj = 0;
7812 wxRect *arg1 = (wxRect *) 0 ;
7813 int arg2 = (int) 0 ;
7814 int arg3 = (int) 0 ;
7815 int arg4 = (int) 0 ;
7816 int arg5 = (int) 0 ;
7817 void *argp1 = 0 ;
7818 int res1 = 0 ;
7819 int val2 ;
7820 int ecode2 = 0 ;
7821 int val3 ;
7822 int ecode3 = 0 ;
7823 int val4 ;
7824 int ecode4 = 0 ;
7825 int val5 ;
7826 int ecode5 = 0 ;
7827 PyObject * obj0 = 0 ;
7828 PyObject * obj1 = 0 ;
7829 PyObject * obj2 = 0 ;
7830 PyObject * obj3 = 0 ;
7831 PyObject * obj4 = 0 ;
7832 char * kwnames[] = {
7833 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7834 };
7835
7836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7838 if (!SWIG_IsOK(res1)) {
7839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7840 }
7841 arg1 = reinterpret_cast< wxRect * >(argp1);
7842 if (obj1) {
7843 ecode2 = SWIG_AsVal_int(obj1, &val2);
7844 if (!SWIG_IsOK(ecode2)) {
7845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7846 }
7847 arg2 = static_cast< int >(val2);
7848 }
7849 if (obj2) {
7850 ecode3 = SWIG_AsVal_int(obj2, &val3);
7851 if (!SWIG_IsOK(ecode3)) {
7852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7853 }
7854 arg3 = static_cast< int >(val3);
7855 }
7856 if (obj3) {
7857 ecode4 = SWIG_AsVal_int(obj3, &val4);
7858 if (!SWIG_IsOK(ecode4)) {
7859 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7860 }
7861 arg4 = static_cast< int >(val4);
7862 }
7863 if (obj4) {
7864 ecode5 = SWIG_AsVal_int(obj4, &val5);
7865 if (!SWIG_IsOK(ecode5)) {
7866 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7867 }
7868 arg5 = static_cast< int >(val5);
7869 }
7870 {
7871 PyThreadState* __tstate = wxPyBeginAllowThreads();
7872 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7873 wxPyEndAllowThreads(__tstate);
7874 if (PyErr_Occurred()) SWIG_fail;
7875 }
7876 resultobj = SWIG_Py_Void();
7877 return resultobj;
7878 fail:
7879 return NULL;
7880 }
7881
7882
7883 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7884 PyObject *resultobj = 0;
7885 wxRect *arg1 = (wxRect *) 0 ;
7886 PyObject *result = 0 ;
7887 void *argp1 = 0 ;
7888 int res1 = 0 ;
7889 PyObject *swig_obj[1] ;
7890
7891 if (!args) SWIG_fail;
7892 swig_obj[0] = args;
7893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7894 if (!SWIG_IsOK(res1)) {
7895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7896 }
7897 arg1 = reinterpret_cast< wxRect * >(argp1);
7898 {
7899 PyThreadState* __tstate = wxPyBeginAllowThreads();
7900 result = (PyObject *)wxRect_Get(arg1);
7901 wxPyEndAllowThreads(__tstate);
7902 if (PyErr_Occurred()) SWIG_fail;
7903 }
7904 resultobj = result;
7905 return resultobj;
7906 fail:
7907 return NULL;
7908 }
7909
7910
7911 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7912 PyObject *obj;
7913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7914 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7915 return SWIG_Py_Void();
7916 }
7917
7918 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7919 return SWIG_Python_InitShadowInstance(args);
7920 }
7921
7922 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7923 PyObject *resultobj = 0;
7924 wxRect *arg1 = (wxRect *) 0 ;
7925 wxRect *arg2 = (wxRect *) 0 ;
7926 PyObject *result = 0 ;
7927 void *argp1 = 0 ;
7928 int res1 = 0 ;
7929 void *argp2 = 0 ;
7930 int res2 = 0 ;
7931 PyObject * obj0 = 0 ;
7932 PyObject * obj1 = 0 ;
7933 char * kwnames[] = {
7934 (char *) "r1",(char *) "r2", NULL
7935 };
7936
7937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7939 if (!SWIG_IsOK(res1)) {
7940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7941 }
7942 arg1 = reinterpret_cast< wxRect * >(argp1);
7943 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7944 if (!SWIG_IsOK(res2)) {
7945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7946 }
7947 arg2 = reinterpret_cast< wxRect * >(argp2);
7948 {
7949 if (!wxPyCheckForApp()) SWIG_fail;
7950 PyThreadState* __tstate = wxPyBeginAllowThreads();
7951 result = (PyObject *)wxIntersectRect(arg1,arg2);
7952 wxPyEndAllowThreads(__tstate);
7953 if (PyErr_Occurred()) SWIG_fail;
7954 }
7955 resultobj = result;
7956 return resultobj;
7957 fail:
7958 return NULL;
7959 }
7960
7961
7962 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7963 PyObject *resultobj = 0;
7964 double arg1 = (double) 0.0 ;
7965 double arg2 = (double) 0.0 ;
7966 wxPoint2D *result = 0 ;
7967 double val1 ;
7968 int ecode1 = 0 ;
7969 double val2 ;
7970 int ecode2 = 0 ;
7971 PyObject * obj0 = 0 ;
7972 PyObject * obj1 = 0 ;
7973 char * kwnames[] = {
7974 (char *) "x",(char *) "y", NULL
7975 };
7976
7977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7978 if (obj0) {
7979 ecode1 = SWIG_AsVal_double(obj0, &val1);
7980 if (!SWIG_IsOK(ecode1)) {
7981 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7982 }
7983 arg1 = static_cast< double >(val1);
7984 }
7985 if (obj1) {
7986 ecode2 = SWIG_AsVal_double(obj1, &val2);
7987 if (!SWIG_IsOK(ecode2)) {
7988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7989 }
7990 arg2 = static_cast< double >(val2);
7991 }
7992 {
7993 PyThreadState* __tstate = wxPyBeginAllowThreads();
7994 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7995 wxPyEndAllowThreads(__tstate);
7996 if (PyErr_Occurred()) SWIG_fail;
7997 }
7998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7999 return resultobj;
8000 fail:
8001 return NULL;
8002 }
8003
8004
8005 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8006 PyObject *resultobj = 0;
8007 wxPoint2D *arg1 = 0 ;
8008 wxPoint2D *result = 0 ;
8009 wxPoint2D temp1 ;
8010 PyObject * obj0 = 0 ;
8011 char * kwnames[] = {
8012 (char *) "pt", NULL
8013 };
8014
8015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8016 {
8017 arg1 = &temp1;
8018 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8019 }
8020 {
8021 PyThreadState* __tstate = wxPyBeginAllowThreads();
8022 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8023 wxPyEndAllowThreads(__tstate);
8024 if (PyErr_Occurred()) SWIG_fail;
8025 }
8026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8027 return resultobj;
8028 fail:
8029 return NULL;
8030 }
8031
8032
8033 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8034 PyObject *resultobj = 0;
8035 wxPoint *arg1 = 0 ;
8036 wxPoint2D *result = 0 ;
8037 wxPoint temp1 ;
8038 PyObject * obj0 = 0 ;
8039 char * kwnames[] = {
8040 (char *) "pt", NULL
8041 };
8042
8043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8044 {
8045 arg1 = &temp1;
8046 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8047 }
8048 {
8049 PyThreadState* __tstate = wxPyBeginAllowThreads();
8050 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8051 wxPyEndAllowThreads(__tstate);
8052 if (PyErr_Occurred()) SWIG_fail;
8053 }
8054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8055 return resultobj;
8056 fail:
8057 return NULL;
8058 }
8059
8060
8061 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8062 PyObject *resultobj = 0;
8063 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8064 int *arg2 = (int *) 0 ;
8065 int *arg3 = (int *) 0 ;
8066 void *argp1 = 0 ;
8067 int res1 = 0 ;
8068 int temp2 ;
8069 int res2 = SWIG_TMPOBJ ;
8070 int temp3 ;
8071 int res3 = SWIG_TMPOBJ ;
8072 PyObject *swig_obj[1] ;
8073
8074 arg2 = &temp2;
8075 arg3 = &temp3;
8076 if (!args) SWIG_fail;
8077 swig_obj[0] = args;
8078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8079 if (!SWIG_IsOK(res1)) {
8080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8081 }
8082 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8083 {
8084 PyThreadState* __tstate = wxPyBeginAllowThreads();
8085 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8086 wxPyEndAllowThreads(__tstate);
8087 if (PyErr_Occurred()) SWIG_fail;
8088 }
8089 resultobj = SWIG_Py_Void();
8090 if (SWIG_IsTmpObj(res2)) {
8091 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8092 } else {
8093 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8094 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8095 }
8096 if (SWIG_IsTmpObj(res3)) {
8097 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8098 } else {
8099 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8100 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8101 }
8102 return resultobj;
8103 fail:
8104 return NULL;
8105 }
8106
8107
8108 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8109 PyObject *resultobj = 0;
8110 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8111 int *arg2 = (int *) 0 ;
8112 int *arg3 = (int *) 0 ;
8113 void *argp1 = 0 ;
8114 int res1 = 0 ;
8115 int temp2 ;
8116 int res2 = SWIG_TMPOBJ ;
8117 int temp3 ;
8118 int res3 = SWIG_TMPOBJ ;
8119 PyObject *swig_obj[1] ;
8120
8121 arg2 = &temp2;
8122 arg3 = &temp3;
8123 if (!args) SWIG_fail;
8124 swig_obj[0] = args;
8125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8126 if (!SWIG_IsOK(res1)) {
8127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8128 }
8129 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8130 {
8131 PyThreadState* __tstate = wxPyBeginAllowThreads();
8132 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8133 wxPyEndAllowThreads(__tstate);
8134 if (PyErr_Occurred()) SWIG_fail;
8135 }
8136 resultobj = SWIG_Py_Void();
8137 if (SWIG_IsTmpObj(res2)) {
8138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8139 } else {
8140 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8141 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8142 }
8143 if (SWIG_IsTmpObj(res3)) {
8144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8145 } else {
8146 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8147 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8148 }
8149 return resultobj;
8150 fail:
8151 return NULL;
8152 }
8153
8154
8155 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8156 PyObject *resultobj = 0;
8157 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8158 double result;
8159 void *argp1 = 0 ;
8160 int res1 = 0 ;
8161 PyObject *swig_obj[1] ;
8162
8163 if (!args) SWIG_fail;
8164 swig_obj[0] = args;
8165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8166 if (!SWIG_IsOK(res1)) {
8167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8168 }
8169 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8170 {
8171 PyThreadState* __tstate = wxPyBeginAllowThreads();
8172 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8173 wxPyEndAllowThreads(__tstate);
8174 if (PyErr_Occurred()) SWIG_fail;
8175 }
8176 resultobj = SWIG_From_double(static_cast< double >(result));
8177 return resultobj;
8178 fail:
8179 return NULL;
8180 }
8181
8182
8183 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8184 PyObject *resultobj = 0;
8185 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8186 double result;
8187 void *argp1 = 0 ;
8188 int res1 = 0 ;
8189 PyObject *swig_obj[1] ;
8190
8191 if (!args) SWIG_fail;
8192 swig_obj[0] = args;
8193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8194 if (!SWIG_IsOK(res1)) {
8195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8196 }
8197 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8198 {
8199 PyThreadState* __tstate = wxPyBeginAllowThreads();
8200 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8201 wxPyEndAllowThreads(__tstate);
8202 if (PyErr_Occurred()) SWIG_fail;
8203 }
8204 resultobj = SWIG_From_double(static_cast< double >(result));
8205 return resultobj;
8206 fail:
8207 return NULL;
8208 }
8209
8210
8211 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8212 PyObject *resultobj = 0;
8213 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8214 double arg2 ;
8215 void *argp1 = 0 ;
8216 int res1 = 0 ;
8217 double val2 ;
8218 int ecode2 = 0 ;
8219 PyObject * obj0 = 0 ;
8220 PyObject * obj1 = 0 ;
8221 char * kwnames[] = {
8222 (char *) "self",(char *) "length", NULL
8223 };
8224
8225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8227 if (!SWIG_IsOK(res1)) {
8228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8229 }
8230 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8231 ecode2 = SWIG_AsVal_double(obj1, &val2);
8232 if (!SWIG_IsOK(ecode2)) {
8233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8234 }
8235 arg2 = static_cast< double >(val2);
8236 {
8237 PyThreadState* __tstate = wxPyBeginAllowThreads();
8238 (arg1)->SetVectorLength(arg2);
8239 wxPyEndAllowThreads(__tstate);
8240 if (PyErr_Occurred()) SWIG_fail;
8241 }
8242 resultobj = SWIG_Py_Void();
8243 return resultobj;
8244 fail:
8245 return NULL;
8246 }
8247
8248
8249 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8250 PyObject *resultobj = 0;
8251 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8252 double arg2 ;
8253 void *argp1 = 0 ;
8254 int res1 = 0 ;
8255 double val2 ;
8256 int ecode2 = 0 ;
8257 PyObject * obj0 = 0 ;
8258 PyObject * obj1 = 0 ;
8259 char * kwnames[] = {
8260 (char *) "self",(char *) "degrees", NULL
8261 };
8262
8263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8265 if (!SWIG_IsOK(res1)) {
8266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8267 }
8268 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8269 ecode2 = SWIG_AsVal_double(obj1, &val2);
8270 if (!SWIG_IsOK(ecode2)) {
8271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8272 }
8273 arg2 = static_cast< double >(val2);
8274 {
8275 PyThreadState* __tstate = wxPyBeginAllowThreads();
8276 (arg1)->SetVectorAngle(arg2);
8277 wxPyEndAllowThreads(__tstate);
8278 if (PyErr_Occurred()) SWIG_fail;
8279 }
8280 resultobj = SWIG_Py_Void();
8281 return resultobj;
8282 fail:
8283 return NULL;
8284 }
8285
8286
8287 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8288 PyObject *resultobj = 0;
8289 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8290 wxPoint2D *arg2 = 0 ;
8291 double result;
8292 void *argp1 = 0 ;
8293 int res1 = 0 ;
8294 wxPoint2D temp2 ;
8295 PyObject * obj0 = 0 ;
8296 PyObject * obj1 = 0 ;
8297 char * kwnames[] = {
8298 (char *) "self",(char *) "pt", NULL
8299 };
8300
8301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8303 if (!SWIG_IsOK(res1)) {
8304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8305 }
8306 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8307 {
8308 arg2 = &temp2;
8309 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8310 }
8311 {
8312 PyThreadState* __tstate = wxPyBeginAllowThreads();
8313 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8314 wxPyEndAllowThreads(__tstate);
8315 if (PyErr_Occurred()) SWIG_fail;
8316 }
8317 resultobj = SWIG_From_double(static_cast< double >(result));
8318 return resultobj;
8319 fail:
8320 return NULL;
8321 }
8322
8323
8324 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8325 PyObject *resultobj = 0;
8326 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8327 wxPoint2D *arg2 = 0 ;
8328 double result;
8329 void *argp1 = 0 ;
8330 int res1 = 0 ;
8331 wxPoint2D temp2 ;
8332 PyObject * obj0 = 0 ;
8333 PyObject * obj1 = 0 ;
8334 char * kwnames[] = {
8335 (char *) "self",(char *) "pt", NULL
8336 };
8337
8338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8340 if (!SWIG_IsOK(res1)) {
8341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8342 }
8343 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8344 {
8345 arg2 = &temp2;
8346 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8347 }
8348 {
8349 PyThreadState* __tstate = wxPyBeginAllowThreads();
8350 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8351 wxPyEndAllowThreads(__tstate);
8352 if (PyErr_Occurred()) SWIG_fail;
8353 }
8354 resultobj = SWIG_From_double(static_cast< double >(result));
8355 return resultobj;
8356 fail:
8357 return NULL;
8358 }
8359
8360
8361 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8362 PyObject *resultobj = 0;
8363 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8364 wxPoint2D *arg2 = 0 ;
8365 double result;
8366 void *argp1 = 0 ;
8367 int res1 = 0 ;
8368 wxPoint2D temp2 ;
8369 PyObject * obj0 = 0 ;
8370 PyObject * obj1 = 0 ;
8371 char * kwnames[] = {
8372 (char *) "self",(char *) "vec", NULL
8373 };
8374
8375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8377 if (!SWIG_IsOK(res1)) {
8378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8379 }
8380 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8381 {
8382 arg2 = &temp2;
8383 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8384 }
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 resultobj = SWIG_From_double(static_cast< double >(result));
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj = 0;
8400 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8401 wxPoint2D *arg2 = 0 ;
8402 double result;
8403 void *argp1 = 0 ;
8404 int res1 = 0 ;
8405 wxPoint2D temp2 ;
8406 PyObject * obj0 = 0 ;
8407 PyObject * obj1 = 0 ;
8408 char * kwnames[] = {
8409 (char *) "self",(char *) "vec", NULL
8410 };
8411
8412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8414 if (!SWIG_IsOK(res1)) {
8415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8416 }
8417 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8418 {
8419 arg2 = &temp2;
8420 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8421 }
8422 {
8423 PyThreadState* __tstate = wxPyBeginAllowThreads();
8424 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8425 wxPyEndAllowThreads(__tstate);
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 resultobj = SWIG_From_double(static_cast< double >(result));
8429 return resultobj;
8430 fail:
8431 return NULL;
8432 }
8433
8434
8435 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8436 PyObject *resultobj = 0;
8437 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8438 wxPoint2D result;
8439 void *argp1 = 0 ;
8440 int res1 = 0 ;
8441 PyObject *swig_obj[1] ;
8442
8443 if (!args) SWIG_fail;
8444 swig_obj[0] = args;
8445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8446 if (!SWIG_IsOK(res1)) {
8447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8448 }
8449 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8450 {
8451 PyThreadState* __tstate = wxPyBeginAllowThreads();
8452 result = (arg1)->operator -();
8453 wxPyEndAllowThreads(__tstate);
8454 if (PyErr_Occurred()) SWIG_fail;
8455 }
8456 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8457 return resultobj;
8458 fail:
8459 return NULL;
8460 }
8461
8462
8463 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8464 PyObject *resultobj = 0;
8465 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8466 wxPoint2D *arg2 = 0 ;
8467 wxPoint2D *result = 0 ;
8468 void *argp1 = 0 ;
8469 int res1 = 0 ;
8470 wxPoint2D temp2 ;
8471 PyObject * obj0 = 0 ;
8472 PyObject * obj1 = 0 ;
8473 char * kwnames[] = {
8474 (char *) "self",(char *) "pt", NULL
8475 };
8476
8477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8479 if (!SWIG_IsOK(res1)) {
8480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8481 }
8482 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8483 {
8484 arg2 = &temp2;
8485 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8486 }
8487 {
8488 PyThreadState* __tstate = wxPyBeginAllowThreads();
8489 {
8490 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8491 result = (wxPoint2D *) &_result_ref;
8492 }
8493 wxPyEndAllowThreads(__tstate);
8494 if (PyErr_Occurred()) SWIG_fail;
8495 }
8496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8497 return resultobj;
8498 fail:
8499 return NULL;
8500 }
8501
8502
8503 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8504 PyObject *resultobj = 0;
8505 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8506 wxPoint2D *arg2 = 0 ;
8507 wxPoint2D *result = 0 ;
8508 void *argp1 = 0 ;
8509 int res1 = 0 ;
8510 wxPoint2D temp2 ;
8511 PyObject * obj0 = 0 ;
8512 PyObject * obj1 = 0 ;
8513 char * kwnames[] = {
8514 (char *) "self",(char *) "pt", NULL
8515 };
8516
8517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8519 if (!SWIG_IsOK(res1)) {
8520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8521 }
8522 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8523 {
8524 arg2 = &temp2;
8525 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8526 }
8527 {
8528 PyThreadState* __tstate = wxPyBeginAllowThreads();
8529 {
8530 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8531 result = (wxPoint2D *) &_result_ref;
8532 }
8533 wxPyEndAllowThreads(__tstate);
8534 if (PyErr_Occurred()) SWIG_fail;
8535 }
8536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8537 return resultobj;
8538 fail:
8539 return NULL;
8540 }
8541
8542
8543 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8544 PyObject *resultobj = 0;
8545 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8546 wxPoint2D *arg2 = 0 ;
8547 wxPoint2D *result = 0 ;
8548 void *argp1 = 0 ;
8549 int res1 = 0 ;
8550 wxPoint2D temp2 ;
8551 PyObject * obj0 = 0 ;
8552 PyObject * obj1 = 0 ;
8553 char * kwnames[] = {
8554 (char *) "self",(char *) "pt", NULL
8555 };
8556
8557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8559 if (!SWIG_IsOK(res1)) {
8560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8561 }
8562 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8563 {
8564 arg2 = &temp2;
8565 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8566 }
8567 {
8568 PyThreadState* __tstate = wxPyBeginAllowThreads();
8569 {
8570 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8571 result = (wxPoint2D *) &_result_ref;
8572 }
8573 wxPyEndAllowThreads(__tstate);
8574 if (PyErr_Occurred()) SWIG_fail;
8575 }
8576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8577 return resultobj;
8578 fail:
8579 return NULL;
8580 }
8581
8582
8583 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8584 PyObject *resultobj = 0;
8585 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8586 wxPoint2D *arg2 = 0 ;
8587 wxPoint2D *result = 0 ;
8588 void *argp1 = 0 ;
8589 int res1 = 0 ;
8590 wxPoint2D temp2 ;
8591 PyObject * obj0 = 0 ;
8592 PyObject * obj1 = 0 ;
8593 char * kwnames[] = {
8594 (char *) "self",(char *) "pt", NULL
8595 };
8596
8597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8599 if (!SWIG_IsOK(res1)) {
8600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8601 }
8602 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8603 {
8604 arg2 = &temp2;
8605 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8606 }
8607 {
8608 PyThreadState* __tstate = wxPyBeginAllowThreads();
8609 {
8610 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8611 result = (wxPoint2D *) &_result_ref;
8612 }
8613 wxPyEndAllowThreads(__tstate);
8614 if (PyErr_Occurred()) SWIG_fail;
8615 }
8616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8617 return resultobj;
8618 fail:
8619 return NULL;
8620 }
8621
8622
8623 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8624 PyObject *resultobj = 0;
8625 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8626 PyObject *arg2 = (PyObject *) 0 ;
8627 bool result;
8628 void *argp1 = 0 ;
8629 int res1 = 0 ;
8630 PyObject * obj0 = 0 ;
8631 PyObject * obj1 = 0 ;
8632 char * kwnames[] = {
8633 (char *) "self",(char *) "other", NULL
8634 };
8635
8636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8638 if (!SWIG_IsOK(res1)) {
8639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8640 }
8641 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8642 arg2 = obj1;
8643 {
8644 result = (bool)wxPoint2D___eq__(arg1,arg2);
8645 if (PyErr_Occurred()) SWIG_fail;
8646 }
8647 {
8648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8649 }
8650 return resultobj;
8651 fail:
8652 return NULL;
8653 }
8654
8655
8656 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8657 PyObject *resultobj = 0;
8658 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8659 PyObject *arg2 = (PyObject *) 0 ;
8660 bool result;
8661 void *argp1 = 0 ;
8662 int res1 = 0 ;
8663 PyObject * obj0 = 0 ;
8664 PyObject * obj1 = 0 ;
8665 char * kwnames[] = {
8666 (char *) "self",(char *) "other", NULL
8667 };
8668
8669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8671 if (!SWIG_IsOK(res1)) {
8672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8673 }
8674 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8675 arg2 = obj1;
8676 {
8677 result = (bool)wxPoint2D___ne__(arg1,arg2);
8678 if (PyErr_Occurred()) SWIG_fail;
8679 }
8680 {
8681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8682 }
8683 return resultobj;
8684 fail:
8685 return NULL;
8686 }
8687
8688
8689 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8690 PyObject *resultobj = 0;
8691 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8692 double arg2 ;
8693 void *argp1 = 0 ;
8694 int res1 = 0 ;
8695 double val2 ;
8696 int ecode2 = 0 ;
8697 PyObject *swig_obj[2] ;
8698
8699 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8701 if (!SWIG_IsOK(res1)) {
8702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8703 }
8704 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8705 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8706 if (!SWIG_IsOK(ecode2)) {
8707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8708 }
8709 arg2 = static_cast< double >(val2);
8710 if (arg1) (arg1)->m_x = arg2;
8711
8712 resultobj = SWIG_Py_Void();
8713 return resultobj;
8714 fail:
8715 return NULL;
8716 }
8717
8718
8719 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8720 PyObject *resultobj = 0;
8721 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8722 double result;
8723 void *argp1 = 0 ;
8724 int res1 = 0 ;
8725 PyObject *swig_obj[1] ;
8726
8727 if (!args) SWIG_fail;
8728 swig_obj[0] = args;
8729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8730 if (!SWIG_IsOK(res1)) {
8731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8732 }
8733 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8734 result = (double) ((arg1)->m_x);
8735 resultobj = SWIG_From_double(static_cast< double >(result));
8736 return resultobj;
8737 fail:
8738 return NULL;
8739 }
8740
8741
8742 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8743 PyObject *resultobj = 0;
8744 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8745 double arg2 ;
8746 void *argp1 = 0 ;
8747 int res1 = 0 ;
8748 double val2 ;
8749 int ecode2 = 0 ;
8750 PyObject *swig_obj[2] ;
8751
8752 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8754 if (!SWIG_IsOK(res1)) {
8755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8756 }
8757 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8758 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8759 if (!SWIG_IsOK(ecode2)) {
8760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8761 }
8762 arg2 = static_cast< double >(val2);
8763 if (arg1) (arg1)->m_y = arg2;
8764
8765 resultobj = SWIG_Py_Void();
8766 return resultobj;
8767 fail:
8768 return NULL;
8769 }
8770
8771
8772 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8773 PyObject *resultobj = 0;
8774 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8775 double result;
8776 void *argp1 = 0 ;
8777 int res1 = 0 ;
8778 PyObject *swig_obj[1] ;
8779
8780 if (!args) SWIG_fail;
8781 swig_obj[0] = args;
8782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8783 if (!SWIG_IsOK(res1)) {
8784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8785 }
8786 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8787 result = (double) ((arg1)->m_y);
8788 resultobj = SWIG_From_double(static_cast< double >(result));
8789 return resultobj;
8790 fail:
8791 return NULL;
8792 }
8793
8794
8795 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8796 PyObject *resultobj = 0;
8797 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8798 double arg2 = (double) 0 ;
8799 double arg3 = (double) 0 ;
8800 void *argp1 = 0 ;
8801 int res1 = 0 ;
8802 double val2 ;
8803 int ecode2 = 0 ;
8804 double val3 ;
8805 int ecode3 = 0 ;
8806 PyObject * obj0 = 0 ;
8807 PyObject * obj1 = 0 ;
8808 PyObject * obj2 = 0 ;
8809 char * kwnames[] = {
8810 (char *) "self",(char *) "x",(char *) "y", NULL
8811 };
8812
8813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8815 if (!SWIG_IsOK(res1)) {
8816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8817 }
8818 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8819 if (obj1) {
8820 ecode2 = SWIG_AsVal_double(obj1, &val2);
8821 if (!SWIG_IsOK(ecode2)) {
8822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8823 }
8824 arg2 = static_cast< double >(val2);
8825 }
8826 if (obj2) {
8827 ecode3 = SWIG_AsVal_double(obj2, &val3);
8828 if (!SWIG_IsOK(ecode3)) {
8829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8830 }
8831 arg3 = static_cast< double >(val3);
8832 }
8833 {
8834 PyThreadState* __tstate = wxPyBeginAllowThreads();
8835 wxPoint2D_Set(arg1,arg2,arg3);
8836 wxPyEndAllowThreads(__tstate);
8837 if (PyErr_Occurred()) SWIG_fail;
8838 }
8839 resultobj = SWIG_Py_Void();
8840 return resultobj;
8841 fail:
8842 return NULL;
8843 }
8844
8845
8846 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8847 PyObject *resultobj = 0;
8848 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8849 PyObject *result = 0 ;
8850 void *argp1 = 0 ;
8851 int res1 = 0 ;
8852 PyObject *swig_obj[1] ;
8853
8854 if (!args) SWIG_fail;
8855 swig_obj[0] = args;
8856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8857 if (!SWIG_IsOK(res1)) {
8858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8859 }
8860 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8861 {
8862 PyThreadState* __tstate = wxPyBeginAllowThreads();
8863 result = (PyObject *)wxPoint2D_Get(arg1);
8864 wxPyEndAllowThreads(__tstate);
8865 if (PyErr_Occurred()) SWIG_fail;
8866 }
8867 resultobj = result;
8868 return resultobj;
8869 fail:
8870 return NULL;
8871 }
8872
8873
8874 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8875 PyObject *obj;
8876 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8877 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8878 return SWIG_Py_Void();
8879 }
8880
8881 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8882 return SWIG_Python_InitShadowInstance(args);
8883 }
8884
8885 SWIGINTERN int DefaultPosition_set(PyObject *) {
8886 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8887 return 1;
8888 }
8889
8890
8891 SWIGINTERN PyObject *DefaultPosition_get(void) {
8892 PyObject *pyobj = 0;
8893
8894 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8895 return pyobj;
8896 }
8897
8898
8899 SWIGINTERN int DefaultSize_set(PyObject *) {
8900 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8901 return 1;
8902 }
8903
8904
8905 SWIGINTERN PyObject *DefaultSize_get(void) {
8906 PyObject *pyobj = 0;
8907
8908 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8909 return pyobj;
8910 }
8911
8912
8913 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8914 PyObject *resultobj = 0;
8915 PyObject *arg1 = (PyObject *) 0 ;
8916 wxPyInputStream *result = 0 ;
8917 PyObject * obj0 = 0 ;
8918 char * kwnames[] = {
8919 (char *) "p", NULL
8920 };
8921
8922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8923 arg1 = obj0;
8924 {
8925 PyThreadState* __tstate = wxPyBeginAllowThreads();
8926 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8927 wxPyEndAllowThreads(__tstate);
8928 if (PyErr_Occurred()) SWIG_fail;
8929 }
8930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8931 return resultobj;
8932 fail:
8933 return NULL;
8934 }
8935
8936
8937 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8938 PyObject *resultobj = 0;
8939 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8940 void *argp1 = 0 ;
8941 int res1 = 0 ;
8942 PyObject *swig_obj[1] ;
8943
8944 if (!args) SWIG_fail;
8945 swig_obj[0] = args;
8946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8947 if (!SWIG_IsOK(res1)) {
8948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8949 }
8950 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8951 {
8952 PyThreadState* __tstate = wxPyBeginAllowThreads();
8953 delete arg1;
8954
8955 wxPyEndAllowThreads(__tstate);
8956 if (PyErr_Occurred()) SWIG_fail;
8957 }
8958 resultobj = SWIG_Py_Void();
8959 return resultobj;
8960 fail:
8961 return NULL;
8962 }
8963
8964
8965 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8966 PyObject *resultobj = 0;
8967 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8968 void *argp1 = 0 ;
8969 int res1 = 0 ;
8970 PyObject *swig_obj[1] ;
8971
8972 if (!args) SWIG_fail;
8973 swig_obj[0] = args;
8974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8975 if (!SWIG_IsOK(res1)) {
8976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8977 }
8978 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8979 {
8980 PyThreadState* __tstate = wxPyBeginAllowThreads();
8981 (arg1)->close();
8982 wxPyEndAllowThreads(__tstate);
8983 if (PyErr_Occurred()) SWIG_fail;
8984 }
8985 resultobj = SWIG_Py_Void();
8986 return resultobj;
8987 fail:
8988 return NULL;
8989 }
8990
8991
8992 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8993 PyObject *resultobj = 0;
8994 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8995 void *argp1 = 0 ;
8996 int res1 = 0 ;
8997 PyObject *swig_obj[1] ;
8998
8999 if (!args) SWIG_fail;
9000 swig_obj[0] = args;
9001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9002 if (!SWIG_IsOK(res1)) {
9003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9004 }
9005 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9006 {
9007 PyThreadState* __tstate = wxPyBeginAllowThreads();
9008 (arg1)->flush();
9009 wxPyEndAllowThreads(__tstate);
9010 if (PyErr_Occurred()) SWIG_fail;
9011 }
9012 resultobj = SWIG_Py_Void();
9013 return resultobj;
9014 fail:
9015 return NULL;
9016 }
9017
9018
9019 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9020 PyObject *resultobj = 0;
9021 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9022 bool result;
9023 void *argp1 = 0 ;
9024 int res1 = 0 ;
9025 PyObject *swig_obj[1] ;
9026
9027 if (!args) SWIG_fail;
9028 swig_obj[0] = args;
9029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9030 if (!SWIG_IsOK(res1)) {
9031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9032 }
9033 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9034 {
9035 PyThreadState* __tstate = wxPyBeginAllowThreads();
9036 result = (bool)(arg1)->eof();
9037 wxPyEndAllowThreads(__tstate);
9038 if (PyErr_Occurred()) SWIG_fail;
9039 }
9040 {
9041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9042 }
9043 return resultobj;
9044 fail:
9045 return NULL;
9046 }
9047
9048
9049 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9050 PyObject *resultobj = 0;
9051 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9052 int arg2 = (int) -1 ;
9053 PyObject *result = 0 ;
9054 void *argp1 = 0 ;
9055 int res1 = 0 ;
9056 int val2 ;
9057 int ecode2 = 0 ;
9058 PyObject * obj0 = 0 ;
9059 PyObject * obj1 = 0 ;
9060 char * kwnames[] = {
9061 (char *) "self",(char *) "size", NULL
9062 };
9063
9064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9066 if (!SWIG_IsOK(res1)) {
9067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9068 }
9069 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9070 if (obj1) {
9071 ecode2 = SWIG_AsVal_int(obj1, &val2);
9072 if (!SWIG_IsOK(ecode2)) {
9073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9074 }
9075 arg2 = static_cast< int >(val2);
9076 }
9077 {
9078 PyThreadState* __tstate = wxPyBeginAllowThreads();
9079 result = (PyObject *)(arg1)->read(arg2);
9080 wxPyEndAllowThreads(__tstate);
9081 if (PyErr_Occurred()) SWIG_fail;
9082 }
9083 resultobj = result;
9084 return resultobj;
9085 fail:
9086 return NULL;
9087 }
9088
9089
9090 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9091 PyObject *resultobj = 0;
9092 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9093 int arg2 = (int) -1 ;
9094 PyObject *result = 0 ;
9095 void *argp1 = 0 ;
9096 int res1 = 0 ;
9097 int val2 ;
9098 int ecode2 = 0 ;
9099 PyObject * obj0 = 0 ;
9100 PyObject * obj1 = 0 ;
9101 char * kwnames[] = {
9102 (char *) "self",(char *) "size", NULL
9103 };
9104
9105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9107 if (!SWIG_IsOK(res1)) {
9108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9109 }
9110 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9111 if (obj1) {
9112 ecode2 = SWIG_AsVal_int(obj1, &val2);
9113 if (!SWIG_IsOK(ecode2)) {
9114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9115 }
9116 arg2 = static_cast< int >(val2);
9117 }
9118 {
9119 PyThreadState* __tstate = wxPyBeginAllowThreads();
9120 result = (PyObject *)(arg1)->readline(arg2);
9121 wxPyEndAllowThreads(__tstate);
9122 if (PyErr_Occurred()) SWIG_fail;
9123 }
9124 resultobj = result;
9125 return resultobj;
9126 fail:
9127 return NULL;
9128 }
9129
9130
9131 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9132 PyObject *resultobj = 0;
9133 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9134 int arg2 = (int) -1 ;
9135 PyObject *result = 0 ;
9136 void *argp1 = 0 ;
9137 int res1 = 0 ;
9138 int val2 ;
9139 int ecode2 = 0 ;
9140 PyObject * obj0 = 0 ;
9141 PyObject * obj1 = 0 ;
9142 char * kwnames[] = {
9143 (char *) "self",(char *) "sizehint", NULL
9144 };
9145
9146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9148 if (!SWIG_IsOK(res1)) {
9149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9150 }
9151 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9152 if (obj1) {
9153 ecode2 = SWIG_AsVal_int(obj1, &val2);
9154 if (!SWIG_IsOK(ecode2)) {
9155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9156 }
9157 arg2 = static_cast< int >(val2);
9158 }
9159 {
9160 PyThreadState* __tstate = wxPyBeginAllowThreads();
9161 result = (PyObject *)(arg1)->readlines(arg2);
9162 wxPyEndAllowThreads(__tstate);
9163 if (PyErr_Occurred()) SWIG_fail;
9164 }
9165 resultobj = result;
9166 return resultobj;
9167 fail:
9168 return NULL;
9169 }
9170
9171
9172 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9173 PyObject *resultobj = 0;
9174 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9175 int arg2 ;
9176 int arg3 = (int) 0 ;
9177 void *argp1 = 0 ;
9178 int res1 = 0 ;
9179 int val2 ;
9180 int ecode2 = 0 ;
9181 int val3 ;
9182 int ecode3 = 0 ;
9183 PyObject * obj0 = 0 ;
9184 PyObject * obj1 = 0 ;
9185 PyObject * obj2 = 0 ;
9186 char * kwnames[] = {
9187 (char *) "self",(char *) "offset",(char *) "whence", NULL
9188 };
9189
9190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9192 if (!SWIG_IsOK(res1)) {
9193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9194 }
9195 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9196 ecode2 = SWIG_AsVal_int(obj1, &val2);
9197 if (!SWIG_IsOK(ecode2)) {
9198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9199 }
9200 arg2 = static_cast< int >(val2);
9201 if (obj2) {
9202 ecode3 = SWIG_AsVal_int(obj2, &val3);
9203 if (!SWIG_IsOK(ecode3)) {
9204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9205 }
9206 arg3 = static_cast< int >(val3);
9207 }
9208 {
9209 PyThreadState* __tstate = wxPyBeginAllowThreads();
9210 (arg1)->seek(arg2,arg3);
9211 wxPyEndAllowThreads(__tstate);
9212 if (PyErr_Occurred()) SWIG_fail;
9213 }
9214 resultobj = SWIG_Py_Void();
9215 return resultobj;
9216 fail:
9217 return NULL;
9218 }
9219
9220
9221 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9222 PyObject *resultobj = 0;
9223 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9224 int result;
9225 void *argp1 = 0 ;
9226 int res1 = 0 ;
9227 PyObject *swig_obj[1] ;
9228
9229 if (!args) SWIG_fail;
9230 swig_obj[0] = args;
9231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9232 if (!SWIG_IsOK(res1)) {
9233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9234 }
9235 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9236 {
9237 PyThreadState* __tstate = wxPyBeginAllowThreads();
9238 result = (int)(arg1)->tell();
9239 wxPyEndAllowThreads(__tstate);
9240 if (PyErr_Occurred()) SWIG_fail;
9241 }
9242 resultobj = SWIG_From_int(static_cast< int >(result));
9243 return resultobj;
9244 fail:
9245 return NULL;
9246 }
9247
9248
9249 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9250 PyObject *resultobj = 0;
9251 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9252 char result;
9253 void *argp1 = 0 ;
9254 int res1 = 0 ;
9255 PyObject *swig_obj[1] ;
9256
9257 if (!args) SWIG_fail;
9258 swig_obj[0] = args;
9259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9260 if (!SWIG_IsOK(res1)) {
9261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9262 }
9263 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9264 {
9265 PyThreadState* __tstate = wxPyBeginAllowThreads();
9266 result = (char)(arg1)->Peek();
9267 wxPyEndAllowThreads(__tstate);
9268 if (PyErr_Occurred()) SWIG_fail;
9269 }
9270 resultobj = SWIG_From_char(static_cast< char >(result));
9271 return resultobj;
9272 fail:
9273 return NULL;
9274 }
9275
9276
9277 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9278 PyObject *resultobj = 0;
9279 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9280 char result;
9281 void *argp1 = 0 ;
9282 int res1 = 0 ;
9283 PyObject *swig_obj[1] ;
9284
9285 if (!args) SWIG_fail;
9286 swig_obj[0] = args;
9287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9288 if (!SWIG_IsOK(res1)) {
9289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9290 }
9291 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9292 {
9293 PyThreadState* __tstate = wxPyBeginAllowThreads();
9294 result = (char)(arg1)->GetC();
9295 wxPyEndAllowThreads(__tstate);
9296 if (PyErr_Occurred()) SWIG_fail;
9297 }
9298 resultobj = SWIG_From_char(static_cast< char >(result));
9299 return resultobj;
9300 fail:
9301 return NULL;
9302 }
9303
9304
9305 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9306 PyObject *resultobj = 0;
9307 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9308 size_t result;
9309 void *argp1 = 0 ;
9310 int res1 = 0 ;
9311 PyObject *swig_obj[1] ;
9312
9313 if (!args) SWIG_fail;
9314 swig_obj[0] = args;
9315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9316 if (!SWIG_IsOK(res1)) {
9317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9318 }
9319 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9320 {
9321 PyThreadState* __tstate = wxPyBeginAllowThreads();
9322 result = (size_t)(arg1)->LastRead();
9323 wxPyEndAllowThreads(__tstate);
9324 if (PyErr_Occurred()) SWIG_fail;
9325 }
9326 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9327 return resultobj;
9328 fail:
9329 return NULL;
9330 }
9331
9332
9333 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9334 PyObject *resultobj = 0;
9335 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9336 bool result;
9337 void *argp1 = 0 ;
9338 int res1 = 0 ;
9339 PyObject *swig_obj[1] ;
9340
9341 if (!args) SWIG_fail;
9342 swig_obj[0] = args;
9343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9344 if (!SWIG_IsOK(res1)) {
9345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9346 }
9347 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9348 {
9349 PyThreadState* __tstate = wxPyBeginAllowThreads();
9350 result = (bool)(arg1)->CanRead();
9351 wxPyEndAllowThreads(__tstate);
9352 if (PyErr_Occurred()) SWIG_fail;
9353 }
9354 {
9355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9356 }
9357 return resultobj;
9358 fail:
9359 return NULL;
9360 }
9361
9362
9363 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9364 PyObject *resultobj = 0;
9365 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9366 bool result;
9367 void *argp1 = 0 ;
9368 int res1 = 0 ;
9369 PyObject *swig_obj[1] ;
9370
9371 if (!args) SWIG_fail;
9372 swig_obj[0] = args;
9373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9374 if (!SWIG_IsOK(res1)) {
9375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9376 }
9377 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9378 {
9379 PyThreadState* __tstate = wxPyBeginAllowThreads();
9380 result = (bool)(arg1)->Eof();
9381 wxPyEndAllowThreads(__tstate);
9382 if (PyErr_Occurred()) SWIG_fail;
9383 }
9384 {
9385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9386 }
9387 return resultobj;
9388 fail:
9389 return NULL;
9390 }
9391
9392
9393 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9394 PyObject *resultobj = 0;
9395 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9396 char arg2 ;
9397 bool result;
9398 void *argp1 = 0 ;
9399 int res1 = 0 ;
9400 char val2 ;
9401 int ecode2 = 0 ;
9402 PyObject * obj0 = 0 ;
9403 PyObject * obj1 = 0 ;
9404 char * kwnames[] = {
9405 (char *) "self",(char *) "c", NULL
9406 };
9407
9408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9410 if (!SWIG_IsOK(res1)) {
9411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9412 }
9413 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9414 ecode2 = SWIG_AsVal_char(obj1, &val2);
9415 if (!SWIG_IsOK(ecode2)) {
9416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9417 }
9418 arg2 = static_cast< char >(val2);
9419 {
9420 PyThreadState* __tstate = wxPyBeginAllowThreads();
9421 result = (bool)(arg1)->Ungetch(arg2);
9422 wxPyEndAllowThreads(__tstate);
9423 if (PyErr_Occurred()) SWIG_fail;
9424 }
9425 {
9426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9427 }
9428 return resultobj;
9429 fail:
9430 return NULL;
9431 }
9432
9433
9434 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9435 PyObject *resultobj = 0;
9436 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9437 long arg2 ;
9438 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9439 long result;
9440 void *argp1 = 0 ;
9441 int res1 = 0 ;
9442 long val2 ;
9443 int ecode2 = 0 ;
9444 int val3 ;
9445 int ecode3 = 0 ;
9446 PyObject * obj0 = 0 ;
9447 PyObject * obj1 = 0 ;
9448 PyObject * obj2 = 0 ;
9449 char * kwnames[] = {
9450 (char *) "self",(char *) "pos",(char *) "mode", NULL
9451 };
9452
9453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9455 if (!SWIG_IsOK(res1)) {
9456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9457 }
9458 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9459 ecode2 = SWIG_AsVal_long(obj1, &val2);
9460 if (!SWIG_IsOK(ecode2)) {
9461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9462 }
9463 arg2 = static_cast< long >(val2);
9464 if (obj2) {
9465 ecode3 = SWIG_AsVal_int(obj2, &val3);
9466 if (!SWIG_IsOK(ecode3)) {
9467 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9468 }
9469 arg3 = static_cast< wxSeekMode >(val3);
9470 }
9471 {
9472 PyThreadState* __tstate = wxPyBeginAllowThreads();
9473 result = (long)(arg1)->SeekI(arg2,arg3);
9474 wxPyEndAllowThreads(__tstate);
9475 if (PyErr_Occurred()) SWIG_fail;
9476 }
9477 resultobj = SWIG_From_long(static_cast< long >(result));
9478 return resultobj;
9479 fail:
9480 return NULL;
9481 }
9482
9483
9484 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9485 PyObject *resultobj = 0;
9486 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9487 long result;
9488 void *argp1 = 0 ;
9489 int res1 = 0 ;
9490 PyObject *swig_obj[1] ;
9491
9492 if (!args) SWIG_fail;
9493 swig_obj[0] = args;
9494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9495 if (!SWIG_IsOK(res1)) {
9496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9497 }
9498 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9499 {
9500 PyThreadState* __tstate = wxPyBeginAllowThreads();
9501 result = (long)(arg1)->TellI();
9502 wxPyEndAllowThreads(__tstate);
9503 if (PyErr_Occurred()) SWIG_fail;
9504 }
9505 resultobj = SWIG_From_long(static_cast< long >(result));
9506 return resultobj;
9507 fail:
9508 return NULL;
9509 }
9510
9511
9512 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9513 PyObject *obj;
9514 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9515 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9516 return SWIG_Py_Void();
9517 }
9518
9519 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9520 return SWIG_Python_InitShadowInstance(args);
9521 }
9522
9523 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9524 PyObject *resultobj = 0;
9525 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9526 PyObject *arg2 = (PyObject *) 0 ;
9527 void *argp1 = 0 ;
9528 int res1 = 0 ;
9529 PyObject * obj0 = 0 ;
9530 PyObject * obj1 = 0 ;
9531 char * kwnames[] = {
9532 (char *) "self",(char *) "obj", NULL
9533 };
9534
9535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9537 if (!SWIG_IsOK(res1)) {
9538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9539 }
9540 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9541 arg2 = obj1;
9542 {
9543 PyThreadState* __tstate = wxPyBeginAllowThreads();
9544 wxOutputStream_write(arg1,arg2);
9545 wxPyEndAllowThreads(__tstate);
9546 if (PyErr_Occurred()) SWIG_fail;
9547 }
9548 resultobj = SWIG_Py_Void();
9549 return resultobj;
9550 fail:
9551 return NULL;
9552 }
9553
9554
9555 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9556 PyObject *resultobj = 0;
9557 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9558 size_t result;
9559 void *argp1 = 0 ;
9560 int res1 = 0 ;
9561 PyObject *swig_obj[1] ;
9562
9563 if (!args) SWIG_fail;
9564 swig_obj[0] = args;
9565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9566 if (!SWIG_IsOK(res1)) {
9567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9568 }
9569 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9570 {
9571 PyThreadState* __tstate = wxPyBeginAllowThreads();
9572 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9573 wxPyEndAllowThreads(__tstate);
9574 if (PyErr_Occurred()) SWIG_fail;
9575 }
9576 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9577 return resultobj;
9578 fail:
9579 return NULL;
9580 }
9581
9582
9583 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9584 PyObject *obj;
9585 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9586 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9587 return SWIG_Py_Void();
9588 }
9589
9590 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9591 PyObject *resultobj = 0;
9592 wxInputStream *arg1 = (wxInputStream *) 0 ;
9593 wxString *arg2 = 0 ;
9594 wxString *arg3 = 0 ;
9595 wxString *arg4 = 0 ;
9596 wxDateTime arg5 ;
9597 wxFSFile *result = 0 ;
9598 wxPyInputStream *temp1 ;
9599 bool temp2 = false ;
9600 bool temp3 = false ;
9601 bool temp4 = false ;
9602 void *argp5 ;
9603 int res5 = 0 ;
9604 PyObject * obj0 = 0 ;
9605 PyObject * obj1 = 0 ;
9606 PyObject * obj2 = 0 ;
9607 PyObject * obj3 = 0 ;
9608 PyObject * obj4 = 0 ;
9609 char * kwnames[] = {
9610 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9611 };
9612
9613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9614 {
9615 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9616 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9617 } else {
9618 PyErr_Clear(); // clear the failure of the wxPyConvert above
9619 arg1 = wxPyCBInputStream_create(obj0, true);
9620 if (arg1 == NULL) {
9621 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9622 SWIG_fail;
9623 }
9624 }
9625 }
9626 {
9627 arg2 = wxString_in_helper(obj1);
9628 if (arg2 == NULL) SWIG_fail;
9629 temp2 = true;
9630 }
9631 {
9632 arg3 = wxString_in_helper(obj2);
9633 if (arg3 == NULL) SWIG_fail;
9634 temp3 = true;
9635 }
9636 {
9637 arg4 = wxString_in_helper(obj3);
9638 if (arg4 == NULL) SWIG_fail;
9639 temp4 = true;
9640 }
9641 {
9642 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9643 if (!SWIG_IsOK(res5)) {
9644 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9645 }
9646 if (!argp5) {
9647 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9648 } else {
9649 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9650 arg5 = *temp;
9651 if (SWIG_IsNewObj(res5)) delete temp;
9652 }
9653 }
9654 {
9655 PyThreadState* __tstate = wxPyBeginAllowThreads();
9656 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9661 {
9662 if (temp2)
9663 delete arg2;
9664 }
9665 {
9666 if (temp3)
9667 delete arg3;
9668 }
9669 {
9670 if (temp4)
9671 delete arg4;
9672 }
9673 return resultobj;
9674 fail:
9675 {
9676 if (temp2)
9677 delete arg2;
9678 }
9679 {
9680 if (temp3)
9681 delete arg3;
9682 }
9683 {
9684 if (temp4)
9685 delete arg4;
9686 }
9687 return NULL;
9688 }
9689
9690
9691 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9692 PyObject *resultobj = 0;
9693 wxFSFile *arg1 = (wxFSFile *) 0 ;
9694 void *argp1 = 0 ;
9695 int res1 = 0 ;
9696 PyObject *swig_obj[1] ;
9697
9698 if (!args) SWIG_fail;
9699 swig_obj[0] = args;
9700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9701 if (!SWIG_IsOK(res1)) {
9702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9703 }
9704 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9705 {
9706 PyThreadState* __tstate = wxPyBeginAllowThreads();
9707 delete arg1;
9708
9709 wxPyEndAllowThreads(__tstate);
9710 if (PyErr_Occurred()) SWIG_fail;
9711 }
9712 resultobj = SWIG_Py_Void();
9713 return resultobj;
9714 fail:
9715 return NULL;
9716 }
9717
9718
9719 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9720 PyObject *resultobj = 0;
9721 wxFSFile *arg1 = (wxFSFile *) 0 ;
9722 wxInputStream *result = 0 ;
9723 void *argp1 = 0 ;
9724 int res1 = 0 ;
9725 PyObject *swig_obj[1] ;
9726
9727 if (!args) SWIG_fail;
9728 swig_obj[0] = args;
9729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9730 if (!SWIG_IsOK(res1)) {
9731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9732 }
9733 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9734 {
9735 PyThreadState* __tstate = wxPyBeginAllowThreads();
9736 result = (wxInputStream *)(arg1)->GetStream();
9737 wxPyEndAllowThreads(__tstate);
9738 if (PyErr_Occurred()) SWIG_fail;
9739 }
9740 {
9741 wxPyInputStream * _ptr = NULL;
9742
9743 if (result) {
9744 _ptr = new wxPyInputStream(result);
9745 }
9746 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9747 }
9748 return resultobj;
9749 fail:
9750 return NULL;
9751 }
9752
9753
9754 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9755 PyObject *resultobj = 0;
9756 wxFSFile *arg1 = (wxFSFile *) 0 ;
9757 wxString *result = 0 ;
9758 void *argp1 = 0 ;
9759 int res1 = 0 ;
9760 PyObject *swig_obj[1] ;
9761
9762 if (!args) SWIG_fail;
9763 swig_obj[0] = args;
9764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9765 if (!SWIG_IsOK(res1)) {
9766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9767 }
9768 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9769 {
9770 PyThreadState* __tstate = wxPyBeginAllowThreads();
9771 {
9772 wxString const &_result_ref = (arg1)->GetMimeType();
9773 result = (wxString *) &_result_ref;
9774 }
9775 wxPyEndAllowThreads(__tstate);
9776 if (PyErr_Occurred()) SWIG_fail;
9777 }
9778 {
9779 #if wxUSE_UNICODE
9780 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9781 #else
9782 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9783 #endif
9784 }
9785 return resultobj;
9786 fail:
9787 return NULL;
9788 }
9789
9790
9791 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9792 PyObject *resultobj = 0;
9793 wxFSFile *arg1 = (wxFSFile *) 0 ;
9794 wxString *result = 0 ;
9795 void *argp1 = 0 ;
9796 int res1 = 0 ;
9797 PyObject *swig_obj[1] ;
9798
9799 if (!args) SWIG_fail;
9800 swig_obj[0] = args;
9801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9802 if (!SWIG_IsOK(res1)) {
9803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9804 }
9805 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9806 {
9807 PyThreadState* __tstate = wxPyBeginAllowThreads();
9808 {
9809 wxString const &_result_ref = (arg1)->GetLocation();
9810 result = (wxString *) &_result_ref;
9811 }
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 {
9816 #if wxUSE_UNICODE
9817 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9818 #else
9819 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9820 #endif
9821 }
9822 return resultobj;
9823 fail:
9824 return NULL;
9825 }
9826
9827
9828 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9829 PyObject *resultobj = 0;
9830 wxFSFile *arg1 = (wxFSFile *) 0 ;
9831 wxString *result = 0 ;
9832 void *argp1 = 0 ;
9833 int res1 = 0 ;
9834 PyObject *swig_obj[1] ;
9835
9836 if (!args) SWIG_fail;
9837 swig_obj[0] = args;
9838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9839 if (!SWIG_IsOK(res1)) {
9840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9841 }
9842 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9843 {
9844 PyThreadState* __tstate = wxPyBeginAllowThreads();
9845 {
9846 wxString const &_result_ref = (arg1)->GetAnchor();
9847 result = (wxString *) &_result_ref;
9848 }
9849 wxPyEndAllowThreads(__tstate);
9850 if (PyErr_Occurred()) SWIG_fail;
9851 }
9852 {
9853 #if wxUSE_UNICODE
9854 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9855 #else
9856 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9857 #endif
9858 }
9859 return resultobj;
9860 fail:
9861 return NULL;
9862 }
9863
9864
9865 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9866 PyObject *resultobj = 0;
9867 wxFSFile *arg1 = (wxFSFile *) 0 ;
9868 wxDateTime result;
9869 void *argp1 = 0 ;
9870 int res1 = 0 ;
9871 PyObject *swig_obj[1] ;
9872
9873 if (!args) SWIG_fail;
9874 swig_obj[0] = args;
9875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9876 if (!SWIG_IsOK(res1)) {
9877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9878 }
9879 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9880 {
9881 PyThreadState* __tstate = wxPyBeginAllowThreads();
9882 result = (arg1)->GetModificationTime();
9883 wxPyEndAllowThreads(__tstate);
9884 if (PyErr_Occurred()) SWIG_fail;
9885 }
9886 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9887 return resultobj;
9888 fail:
9889 return NULL;
9890 }
9891
9892
9893 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9894 PyObject *obj;
9895 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9896 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9897 return SWIG_Py_Void();
9898 }
9899
9900 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9901 return SWIG_Python_InitShadowInstance(args);
9902 }
9903
9904 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9905 PyObject *resultobj = 0;
9906 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9907 void *argp1 = 0 ;
9908 int res1 = 0 ;
9909 PyObject *swig_obj[1] ;
9910
9911 if (!args) SWIG_fail;
9912 swig_obj[0] = args;
9913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9914 if (!SWIG_IsOK(res1)) {
9915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9916 }
9917 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9918 {
9919 PyThreadState* __tstate = wxPyBeginAllowThreads();
9920 delete arg1;
9921
9922 wxPyEndAllowThreads(__tstate);
9923 if (PyErr_Occurred()) SWIG_fail;
9924 }
9925 resultobj = SWIG_Py_Void();
9926 return resultobj;
9927 fail:
9928 return NULL;
9929 }
9930
9931
9932 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9933 PyObject *obj;
9934 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9935 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9936 return SWIG_Py_Void();
9937 }
9938
9939 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9940 PyObject *resultobj = 0;
9941 wxPyFileSystemHandler *result = 0 ;
9942
9943 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9944 {
9945 PyThreadState* __tstate = wxPyBeginAllowThreads();
9946 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9947 wxPyEndAllowThreads(__tstate);
9948 if (PyErr_Occurred()) SWIG_fail;
9949 }
9950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9951 return resultobj;
9952 fail:
9953 return NULL;
9954 }
9955
9956
9957 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9958 PyObject *resultobj = 0;
9959 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9960 PyObject *arg2 = (PyObject *) 0 ;
9961 PyObject *arg3 = (PyObject *) 0 ;
9962 void *argp1 = 0 ;
9963 int res1 = 0 ;
9964 PyObject * obj0 = 0 ;
9965 PyObject * obj1 = 0 ;
9966 PyObject * obj2 = 0 ;
9967 char * kwnames[] = {
9968 (char *) "self",(char *) "self",(char *) "_class", NULL
9969 };
9970
9971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9973 if (!SWIG_IsOK(res1)) {
9974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9975 }
9976 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9977 arg2 = obj1;
9978 arg3 = obj2;
9979 {
9980 PyThreadState* __tstate = wxPyBeginAllowThreads();
9981 (arg1)->_setCallbackInfo(arg2,arg3);
9982 wxPyEndAllowThreads(__tstate);
9983 if (PyErr_Occurred()) SWIG_fail;
9984 }
9985 resultobj = SWIG_Py_Void();
9986 return resultobj;
9987 fail:
9988 return NULL;
9989 }
9990
9991
9992 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9993 PyObject *resultobj = 0;
9994 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9995 wxString *arg2 = 0 ;
9996 bool result;
9997 void *argp1 = 0 ;
9998 int res1 = 0 ;
9999 bool temp2 = false ;
10000 PyObject * obj0 = 0 ;
10001 PyObject * obj1 = 0 ;
10002 char * kwnames[] = {
10003 (char *) "self",(char *) "location", NULL
10004 };
10005
10006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10008 if (!SWIG_IsOK(res1)) {
10009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10010 }
10011 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10012 {
10013 arg2 = wxString_in_helper(obj1);
10014 if (arg2 == NULL) SWIG_fail;
10015 temp2 = true;
10016 }
10017 {
10018 PyThreadState* __tstate = wxPyBeginAllowThreads();
10019 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10020 wxPyEndAllowThreads(__tstate);
10021 if (PyErr_Occurred()) SWIG_fail;
10022 }
10023 {
10024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10025 }
10026 {
10027 if (temp2)
10028 delete arg2;
10029 }
10030 return resultobj;
10031 fail:
10032 {
10033 if (temp2)
10034 delete arg2;
10035 }
10036 return NULL;
10037 }
10038
10039
10040 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10041 PyObject *resultobj = 0;
10042 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10043 wxFileSystem *arg2 = 0 ;
10044 wxString *arg3 = 0 ;
10045 wxFSFile *result = 0 ;
10046 void *argp1 = 0 ;
10047 int res1 = 0 ;
10048 void *argp2 = 0 ;
10049 int res2 = 0 ;
10050 bool temp3 = false ;
10051 PyObject * obj0 = 0 ;
10052 PyObject * obj1 = 0 ;
10053 PyObject * obj2 = 0 ;
10054 char * kwnames[] = {
10055 (char *) "self",(char *) "fs",(char *) "location", NULL
10056 };
10057
10058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10060 if (!SWIG_IsOK(res1)) {
10061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10062 }
10063 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10064 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10065 if (!SWIG_IsOK(res2)) {
10066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10067 }
10068 if (!argp2) {
10069 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10070 }
10071 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10072 {
10073 arg3 = wxString_in_helper(obj2);
10074 if (arg3 == NULL) SWIG_fail;
10075 temp3 = true;
10076 }
10077 {
10078 PyThreadState* __tstate = wxPyBeginAllowThreads();
10079 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10080 wxPyEndAllowThreads(__tstate);
10081 if (PyErr_Occurred()) SWIG_fail;
10082 }
10083 {
10084 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10085 }
10086 {
10087 if (temp3)
10088 delete arg3;
10089 }
10090 return resultobj;
10091 fail:
10092 {
10093 if (temp3)
10094 delete arg3;
10095 }
10096 return NULL;
10097 }
10098
10099
10100 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10101 PyObject *resultobj = 0;
10102 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10103 wxString *arg2 = 0 ;
10104 int arg3 = (int) 0 ;
10105 wxString result;
10106 void *argp1 = 0 ;
10107 int res1 = 0 ;
10108 bool temp2 = false ;
10109 int val3 ;
10110 int ecode3 = 0 ;
10111 PyObject * obj0 = 0 ;
10112 PyObject * obj1 = 0 ;
10113 PyObject * obj2 = 0 ;
10114 char * kwnames[] = {
10115 (char *) "self",(char *) "spec",(char *) "flags", NULL
10116 };
10117
10118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10120 if (!SWIG_IsOK(res1)) {
10121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10122 }
10123 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10124 {
10125 arg2 = wxString_in_helper(obj1);
10126 if (arg2 == NULL) SWIG_fail;
10127 temp2 = true;
10128 }
10129 if (obj2) {
10130 ecode3 = SWIG_AsVal_int(obj2, &val3);
10131 if (!SWIG_IsOK(ecode3)) {
10132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10133 }
10134 arg3 = static_cast< int >(val3);
10135 }
10136 {
10137 PyThreadState* __tstate = wxPyBeginAllowThreads();
10138 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10139 wxPyEndAllowThreads(__tstate);
10140 if (PyErr_Occurred()) SWIG_fail;
10141 }
10142 {
10143 #if wxUSE_UNICODE
10144 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10145 #else
10146 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10147 #endif
10148 }
10149 {
10150 if (temp2)
10151 delete arg2;
10152 }
10153 return resultobj;
10154 fail:
10155 {
10156 if (temp2)
10157 delete arg2;
10158 }
10159 return NULL;
10160 }
10161
10162
10163 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10164 PyObject *resultobj = 0;
10165 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10166 wxString result;
10167 void *argp1 = 0 ;
10168 int res1 = 0 ;
10169 PyObject *swig_obj[1] ;
10170
10171 if (!args) SWIG_fail;
10172 swig_obj[0] = args;
10173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10174 if (!SWIG_IsOK(res1)) {
10175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10176 }
10177 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10178 {
10179 PyThreadState* __tstate = wxPyBeginAllowThreads();
10180 result = (arg1)->FindNext();
10181 wxPyEndAllowThreads(__tstate);
10182 if (PyErr_Occurred()) SWIG_fail;
10183 }
10184 {
10185 #if wxUSE_UNICODE
10186 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10187 #else
10188 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10189 #endif
10190 }
10191 return resultobj;
10192 fail:
10193 return NULL;
10194 }
10195
10196
10197 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10198 PyObject *resultobj = 0;
10199 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10200 wxString *arg2 = 0 ;
10201 wxString result;
10202 void *argp1 = 0 ;
10203 int res1 = 0 ;
10204 bool temp2 = false ;
10205 PyObject * obj0 = 0 ;
10206 PyObject * obj1 = 0 ;
10207 char * kwnames[] = {
10208 (char *) "self",(char *) "location", NULL
10209 };
10210
10211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10213 if (!SWIG_IsOK(res1)) {
10214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10215 }
10216 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10217 {
10218 arg2 = wxString_in_helper(obj1);
10219 if (arg2 == NULL) SWIG_fail;
10220 temp2 = true;
10221 }
10222 {
10223 PyThreadState* __tstate = wxPyBeginAllowThreads();
10224 result = (arg1)->GetProtocol((wxString const &)*arg2);
10225 wxPyEndAllowThreads(__tstate);
10226 if (PyErr_Occurred()) SWIG_fail;
10227 }
10228 {
10229 #if wxUSE_UNICODE
10230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10231 #else
10232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10233 #endif
10234 }
10235 {
10236 if (temp2)
10237 delete arg2;
10238 }
10239 return resultobj;
10240 fail:
10241 {
10242 if (temp2)
10243 delete arg2;
10244 }
10245 return NULL;
10246 }
10247
10248
10249 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10250 PyObject *resultobj = 0;
10251 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10252 wxString *arg2 = 0 ;
10253 wxString result;
10254 void *argp1 = 0 ;
10255 int res1 = 0 ;
10256 bool temp2 = false ;
10257 PyObject * obj0 = 0 ;
10258 PyObject * obj1 = 0 ;
10259 char * kwnames[] = {
10260 (char *) "self",(char *) "location", NULL
10261 };
10262
10263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10265 if (!SWIG_IsOK(res1)) {
10266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10267 }
10268 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10269 {
10270 arg2 = wxString_in_helper(obj1);
10271 if (arg2 == NULL) SWIG_fail;
10272 temp2 = true;
10273 }
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10277 wxPyEndAllowThreads(__tstate);
10278 if (PyErr_Occurred()) SWIG_fail;
10279 }
10280 {
10281 #if wxUSE_UNICODE
10282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10283 #else
10284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10285 #endif
10286 }
10287 {
10288 if (temp2)
10289 delete arg2;
10290 }
10291 return resultobj;
10292 fail:
10293 {
10294 if (temp2)
10295 delete arg2;
10296 }
10297 return NULL;
10298 }
10299
10300
10301 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10302 PyObject *resultobj = 0;
10303 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10304 wxString *arg2 = 0 ;
10305 wxString result;
10306 void *argp1 = 0 ;
10307 int res1 = 0 ;
10308 bool temp2 = false ;
10309 PyObject * obj0 = 0 ;
10310 PyObject * obj1 = 0 ;
10311 char * kwnames[] = {
10312 (char *) "self",(char *) "location", NULL
10313 };
10314
10315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10317 if (!SWIG_IsOK(res1)) {
10318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10319 }
10320 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10321 {
10322 arg2 = wxString_in_helper(obj1);
10323 if (arg2 == NULL) SWIG_fail;
10324 temp2 = true;
10325 }
10326 {
10327 PyThreadState* __tstate = wxPyBeginAllowThreads();
10328 result = (arg1)->GetAnchor((wxString const &)*arg2);
10329 wxPyEndAllowThreads(__tstate);
10330 if (PyErr_Occurred()) SWIG_fail;
10331 }
10332 {
10333 #if wxUSE_UNICODE
10334 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10335 #else
10336 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10337 #endif
10338 }
10339 {
10340 if (temp2)
10341 delete arg2;
10342 }
10343 return resultobj;
10344 fail:
10345 {
10346 if (temp2)
10347 delete arg2;
10348 }
10349 return NULL;
10350 }
10351
10352
10353 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10354 PyObject *resultobj = 0;
10355 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10356 wxString *arg2 = 0 ;
10357 wxString result;
10358 void *argp1 = 0 ;
10359 int res1 = 0 ;
10360 bool temp2 = false ;
10361 PyObject * obj0 = 0 ;
10362 PyObject * obj1 = 0 ;
10363 char * kwnames[] = {
10364 (char *) "self",(char *) "location", NULL
10365 };
10366
10367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10369 if (!SWIG_IsOK(res1)) {
10370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10371 }
10372 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10373 {
10374 arg2 = wxString_in_helper(obj1);
10375 if (arg2 == NULL) SWIG_fail;
10376 temp2 = true;
10377 }
10378 {
10379 PyThreadState* __tstate = wxPyBeginAllowThreads();
10380 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10381 wxPyEndAllowThreads(__tstate);
10382 if (PyErr_Occurred()) SWIG_fail;
10383 }
10384 {
10385 #if wxUSE_UNICODE
10386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10387 #else
10388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10389 #endif
10390 }
10391 {
10392 if (temp2)
10393 delete arg2;
10394 }
10395 return resultobj;
10396 fail:
10397 {
10398 if (temp2)
10399 delete arg2;
10400 }
10401 return NULL;
10402 }
10403
10404
10405 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10406 PyObject *resultobj = 0;
10407 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10408 wxString *arg2 = 0 ;
10409 wxString result;
10410 void *argp1 = 0 ;
10411 int res1 = 0 ;
10412 bool temp2 = false ;
10413 PyObject * obj0 = 0 ;
10414 PyObject * obj1 = 0 ;
10415 char * kwnames[] = {
10416 (char *) "self",(char *) "location", NULL
10417 };
10418
10419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10421 if (!SWIG_IsOK(res1)) {
10422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10423 }
10424 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10425 {
10426 arg2 = wxString_in_helper(obj1);
10427 if (arg2 == NULL) SWIG_fail;
10428 temp2 = true;
10429 }
10430 {
10431 PyThreadState* __tstate = wxPyBeginAllowThreads();
10432 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10433 wxPyEndAllowThreads(__tstate);
10434 if (PyErr_Occurred()) SWIG_fail;
10435 }
10436 {
10437 #if wxUSE_UNICODE
10438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10439 #else
10440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10441 #endif
10442 }
10443 {
10444 if (temp2)
10445 delete arg2;
10446 }
10447 return resultobj;
10448 fail:
10449 {
10450 if (temp2)
10451 delete arg2;
10452 }
10453 return NULL;
10454 }
10455
10456
10457 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10458 PyObject *obj;
10459 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10460 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10461 return SWIG_Py_Void();
10462 }
10463
10464 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10465 return SWIG_Python_InitShadowInstance(args);
10466 }
10467
10468 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10469 PyObject *resultobj = 0;
10470 wxFileSystem *result = 0 ;
10471
10472 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10473 {
10474 PyThreadState* __tstate = wxPyBeginAllowThreads();
10475 result = (wxFileSystem *)new wxFileSystem();
10476 wxPyEndAllowThreads(__tstate);
10477 if (PyErr_Occurred()) SWIG_fail;
10478 }
10479 {
10480 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10481 }
10482 return resultobj;
10483 fail:
10484 return NULL;
10485 }
10486
10487
10488 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10489 PyObject *resultobj = 0;
10490 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10491 void *argp1 = 0 ;
10492 int res1 = 0 ;
10493 PyObject *swig_obj[1] ;
10494
10495 if (!args) SWIG_fail;
10496 swig_obj[0] = args;
10497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10498 if (!SWIG_IsOK(res1)) {
10499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10500 }
10501 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10502 {
10503 PyThreadState* __tstate = wxPyBeginAllowThreads();
10504 delete arg1;
10505
10506 wxPyEndAllowThreads(__tstate);
10507 if (PyErr_Occurred()) SWIG_fail;
10508 }
10509 resultobj = SWIG_Py_Void();
10510 return resultobj;
10511 fail:
10512 return NULL;
10513 }
10514
10515
10516 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10517 PyObject *resultobj = 0;
10518 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10519 wxString *arg2 = 0 ;
10520 bool arg3 = (bool) false ;
10521 void *argp1 = 0 ;
10522 int res1 = 0 ;
10523 bool temp2 = false ;
10524 bool val3 ;
10525 int ecode3 = 0 ;
10526 PyObject * obj0 = 0 ;
10527 PyObject * obj1 = 0 ;
10528 PyObject * obj2 = 0 ;
10529 char * kwnames[] = {
10530 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10531 };
10532
10533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10535 if (!SWIG_IsOK(res1)) {
10536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10537 }
10538 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10539 {
10540 arg2 = wxString_in_helper(obj1);
10541 if (arg2 == NULL) SWIG_fail;
10542 temp2 = true;
10543 }
10544 if (obj2) {
10545 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10546 if (!SWIG_IsOK(ecode3)) {
10547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10548 }
10549 arg3 = static_cast< bool >(val3);
10550 }
10551 {
10552 PyThreadState* __tstate = wxPyBeginAllowThreads();
10553 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10554 wxPyEndAllowThreads(__tstate);
10555 if (PyErr_Occurred()) SWIG_fail;
10556 }
10557 resultobj = SWIG_Py_Void();
10558 {
10559 if (temp2)
10560 delete arg2;
10561 }
10562 return resultobj;
10563 fail:
10564 {
10565 if (temp2)
10566 delete arg2;
10567 }
10568 return NULL;
10569 }
10570
10571
10572 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10573 PyObject *resultobj = 0;
10574 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10575 wxString result;
10576 void *argp1 = 0 ;
10577 int res1 = 0 ;
10578 PyObject *swig_obj[1] ;
10579
10580 if (!args) SWIG_fail;
10581 swig_obj[0] = args;
10582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10583 if (!SWIG_IsOK(res1)) {
10584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10585 }
10586 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10587 {
10588 PyThreadState* __tstate = wxPyBeginAllowThreads();
10589 result = (arg1)->GetPath();
10590 wxPyEndAllowThreads(__tstate);
10591 if (PyErr_Occurred()) SWIG_fail;
10592 }
10593 {
10594 #if wxUSE_UNICODE
10595 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10596 #else
10597 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10598 #endif
10599 }
10600 return resultobj;
10601 fail:
10602 return NULL;
10603 }
10604
10605
10606 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10607 PyObject *resultobj = 0;
10608 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10609 wxString *arg2 = 0 ;
10610 wxFSFile *result = 0 ;
10611 void *argp1 = 0 ;
10612 int res1 = 0 ;
10613 bool temp2 = false ;
10614 PyObject * obj0 = 0 ;
10615 PyObject * obj1 = 0 ;
10616 char * kwnames[] = {
10617 (char *) "self",(char *) "location", NULL
10618 };
10619
10620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10622 if (!SWIG_IsOK(res1)) {
10623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10624 }
10625 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10626 {
10627 arg2 = wxString_in_helper(obj1);
10628 if (arg2 == NULL) SWIG_fail;
10629 temp2 = true;
10630 }
10631 {
10632 PyThreadState* __tstate = wxPyBeginAllowThreads();
10633 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10634 wxPyEndAllowThreads(__tstate);
10635 if (PyErr_Occurred()) SWIG_fail;
10636 }
10637 {
10638 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10639 }
10640 {
10641 if (temp2)
10642 delete arg2;
10643 }
10644 return resultobj;
10645 fail:
10646 {
10647 if (temp2)
10648 delete arg2;
10649 }
10650 return NULL;
10651 }
10652
10653
10654 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10655 PyObject *resultobj = 0;
10656 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10657 wxString *arg2 = 0 ;
10658 int arg3 = (int) 0 ;
10659 wxString result;
10660 void *argp1 = 0 ;
10661 int res1 = 0 ;
10662 bool temp2 = false ;
10663 int val3 ;
10664 int ecode3 = 0 ;
10665 PyObject * obj0 = 0 ;
10666 PyObject * obj1 = 0 ;
10667 PyObject * obj2 = 0 ;
10668 char * kwnames[] = {
10669 (char *) "self",(char *) "spec",(char *) "flags", NULL
10670 };
10671
10672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10674 if (!SWIG_IsOK(res1)) {
10675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10676 }
10677 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10678 {
10679 arg2 = wxString_in_helper(obj1);
10680 if (arg2 == NULL) SWIG_fail;
10681 temp2 = true;
10682 }
10683 if (obj2) {
10684 ecode3 = SWIG_AsVal_int(obj2, &val3);
10685 if (!SWIG_IsOK(ecode3)) {
10686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10687 }
10688 arg3 = static_cast< int >(val3);
10689 }
10690 {
10691 PyThreadState* __tstate = wxPyBeginAllowThreads();
10692 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10693 wxPyEndAllowThreads(__tstate);
10694 if (PyErr_Occurred()) SWIG_fail;
10695 }
10696 {
10697 #if wxUSE_UNICODE
10698 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10699 #else
10700 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10701 #endif
10702 }
10703 {
10704 if (temp2)
10705 delete arg2;
10706 }
10707 return resultobj;
10708 fail:
10709 {
10710 if (temp2)
10711 delete arg2;
10712 }
10713 return NULL;
10714 }
10715
10716
10717 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10718 PyObject *resultobj = 0;
10719 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10720 wxString result;
10721 void *argp1 = 0 ;
10722 int res1 = 0 ;
10723 PyObject *swig_obj[1] ;
10724
10725 if (!args) SWIG_fail;
10726 swig_obj[0] = args;
10727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10728 if (!SWIG_IsOK(res1)) {
10729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10730 }
10731 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10732 {
10733 PyThreadState* __tstate = wxPyBeginAllowThreads();
10734 result = (arg1)->FindNext();
10735 wxPyEndAllowThreads(__tstate);
10736 if (PyErr_Occurred()) SWIG_fail;
10737 }
10738 {
10739 #if wxUSE_UNICODE
10740 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10741 #else
10742 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10743 #endif
10744 }
10745 return resultobj;
10746 fail:
10747 return NULL;
10748 }
10749
10750
10751 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10752 PyObject *resultobj = 0;
10753 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10754 int res1 = 0 ;
10755 PyObject * obj0 = 0 ;
10756 char * kwnames[] = {
10757 (char *) "handler", NULL
10758 };
10759
10760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10761 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10762 if (!SWIG_IsOK(res1)) {
10763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10764 }
10765 {
10766 PyThreadState* __tstate = wxPyBeginAllowThreads();
10767 wxFileSystem::AddHandler(arg1);
10768 wxPyEndAllowThreads(__tstate);
10769 if (PyErr_Occurred()) SWIG_fail;
10770 }
10771 resultobj = SWIG_Py_Void();
10772 return resultobj;
10773 fail:
10774 return NULL;
10775 }
10776
10777
10778 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10779 PyObject *resultobj = 0;
10780
10781 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10782 {
10783 PyThreadState* __tstate = wxPyBeginAllowThreads();
10784 wxFileSystem::CleanUpHandlers();
10785 wxPyEndAllowThreads(__tstate);
10786 if (PyErr_Occurred()) SWIG_fail;
10787 }
10788 resultobj = SWIG_Py_Void();
10789 return resultobj;
10790 fail:
10791 return NULL;
10792 }
10793
10794
10795 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10796 PyObject *resultobj = 0;
10797 wxString *arg1 = 0 ;
10798 wxString result;
10799 bool temp1 = false ;
10800 PyObject * obj0 = 0 ;
10801 char * kwnames[] = {
10802 (char *) "filename", NULL
10803 };
10804
10805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10806 {
10807 arg1 = wxString_in_helper(obj0);
10808 if (arg1 == NULL) SWIG_fail;
10809 temp1 = true;
10810 }
10811 {
10812 PyThreadState* __tstate = wxPyBeginAllowThreads();
10813 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10814 wxPyEndAllowThreads(__tstate);
10815 if (PyErr_Occurred()) SWIG_fail;
10816 }
10817 {
10818 #if wxUSE_UNICODE
10819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10820 #else
10821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10822 #endif
10823 }
10824 {
10825 if (temp1)
10826 delete arg1;
10827 }
10828 return resultobj;
10829 fail:
10830 {
10831 if (temp1)
10832 delete arg1;
10833 }
10834 return NULL;
10835 }
10836
10837
10838 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10839 PyObject *resultobj = 0;
10840 wxString *arg1 = 0 ;
10841 wxString result;
10842 bool temp1 = false ;
10843 PyObject * obj0 = 0 ;
10844 char * kwnames[] = {
10845 (char *) "url", NULL
10846 };
10847
10848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10849 {
10850 arg1 = wxString_in_helper(obj0);
10851 if (arg1 == NULL) SWIG_fail;
10852 temp1 = true;
10853 }
10854 {
10855 PyThreadState* __tstate = wxPyBeginAllowThreads();
10856 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10857 wxPyEndAllowThreads(__tstate);
10858 if (PyErr_Occurred()) SWIG_fail;
10859 }
10860 {
10861 #if wxUSE_UNICODE
10862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10863 #else
10864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10865 #endif
10866 }
10867 {
10868 if (temp1)
10869 delete arg1;
10870 }
10871 return resultobj;
10872 fail:
10873 {
10874 if (temp1)
10875 delete arg1;
10876 }
10877 return NULL;
10878 }
10879
10880
10881 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10882 PyObject *obj;
10883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10884 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10885 return SWIG_Py_Void();
10886 }
10887
10888 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10889 return SWIG_Python_InitShadowInstance(args);
10890 }
10891
10892 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10893 PyObject *resultobj = 0;
10894 wxInternetFSHandler *result = 0 ;
10895
10896 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10897 {
10898 PyThreadState* __tstate = wxPyBeginAllowThreads();
10899 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10900 wxPyEndAllowThreads(__tstate);
10901 if (PyErr_Occurred()) SWIG_fail;
10902 }
10903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10904 return resultobj;
10905 fail:
10906 return NULL;
10907 }
10908
10909
10910 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10911 PyObject *resultobj = 0;
10912 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10913 wxString *arg2 = 0 ;
10914 bool result;
10915 void *argp1 = 0 ;
10916 int res1 = 0 ;
10917 bool temp2 = false ;
10918 PyObject * obj0 = 0 ;
10919 PyObject * obj1 = 0 ;
10920 char * kwnames[] = {
10921 (char *) "self",(char *) "location", NULL
10922 };
10923
10924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10926 if (!SWIG_IsOK(res1)) {
10927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10928 }
10929 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10930 {
10931 arg2 = wxString_in_helper(obj1);
10932 if (arg2 == NULL) SWIG_fail;
10933 temp2 = true;
10934 }
10935 {
10936 PyThreadState* __tstate = wxPyBeginAllowThreads();
10937 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10938 wxPyEndAllowThreads(__tstate);
10939 if (PyErr_Occurred()) SWIG_fail;
10940 }
10941 {
10942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10943 }
10944 {
10945 if (temp2)
10946 delete arg2;
10947 }
10948 return resultobj;
10949 fail:
10950 {
10951 if (temp2)
10952 delete arg2;
10953 }
10954 return NULL;
10955 }
10956
10957
10958 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10959 PyObject *resultobj = 0;
10960 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10961 wxFileSystem *arg2 = 0 ;
10962 wxString *arg3 = 0 ;
10963 wxFSFile *result = 0 ;
10964 void *argp1 = 0 ;
10965 int res1 = 0 ;
10966 void *argp2 = 0 ;
10967 int res2 = 0 ;
10968 bool temp3 = false ;
10969 PyObject * obj0 = 0 ;
10970 PyObject * obj1 = 0 ;
10971 PyObject * obj2 = 0 ;
10972 char * kwnames[] = {
10973 (char *) "self",(char *) "fs",(char *) "location", NULL
10974 };
10975
10976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10978 if (!SWIG_IsOK(res1)) {
10979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10980 }
10981 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10982 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10983 if (!SWIG_IsOK(res2)) {
10984 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10985 }
10986 if (!argp2) {
10987 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10988 }
10989 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10990 {
10991 arg3 = wxString_in_helper(obj2);
10992 if (arg3 == NULL) SWIG_fail;
10993 temp3 = true;
10994 }
10995 {
10996 PyThreadState* __tstate = wxPyBeginAllowThreads();
10997 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10998 wxPyEndAllowThreads(__tstate);
10999 if (PyErr_Occurred()) SWIG_fail;
11000 }
11001 {
11002 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11003 }
11004 {
11005 if (temp3)
11006 delete arg3;
11007 }
11008 return resultobj;
11009 fail:
11010 {
11011 if (temp3)
11012 delete arg3;
11013 }
11014 return NULL;
11015 }
11016
11017
11018 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11019 PyObject *obj;
11020 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11021 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11022 return SWIG_Py_Void();
11023 }
11024
11025 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11026 return SWIG_Python_InitShadowInstance(args);
11027 }
11028
11029 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11030 PyObject *resultobj = 0;
11031 wxZipFSHandler *result = 0 ;
11032
11033 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11034 {
11035 PyThreadState* __tstate = wxPyBeginAllowThreads();
11036 result = (wxZipFSHandler *)new wxZipFSHandler();
11037 wxPyEndAllowThreads(__tstate);
11038 if (PyErr_Occurred()) SWIG_fail;
11039 }
11040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11041 return resultobj;
11042 fail:
11043 return NULL;
11044 }
11045
11046
11047 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11048 PyObject *resultobj = 0;
11049 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11050 wxString *arg2 = 0 ;
11051 bool result;
11052 void *argp1 = 0 ;
11053 int res1 = 0 ;
11054 bool temp2 = false ;
11055 PyObject * obj0 = 0 ;
11056 PyObject * obj1 = 0 ;
11057 char * kwnames[] = {
11058 (char *) "self",(char *) "location", NULL
11059 };
11060
11061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11063 if (!SWIG_IsOK(res1)) {
11064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11065 }
11066 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11067 {
11068 arg2 = wxString_in_helper(obj1);
11069 if (arg2 == NULL) SWIG_fail;
11070 temp2 = true;
11071 }
11072 {
11073 PyThreadState* __tstate = wxPyBeginAllowThreads();
11074 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11075 wxPyEndAllowThreads(__tstate);
11076 if (PyErr_Occurred()) SWIG_fail;
11077 }
11078 {
11079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11080 }
11081 {
11082 if (temp2)
11083 delete arg2;
11084 }
11085 return resultobj;
11086 fail:
11087 {
11088 if (temp2)
11089 delete arg2;
11090 }
11091 return NULL;
11092 }
11093
11094
11095 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11096 PyObject *resultobj = 0;
11097 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11098 wxFileSystem *arg2 = 0 ;
11099 wxString *arg3 = 0 ;
11100 wxFSFile *result = 0 ;
11101 void *argp1 = 0 ;
11102 int res1 = 0 ;
11103 void *argp2 = 0 ;
11104 int res2 = 0 ;
11105 bool temp3 = false ;
11106 PyObject * obj0 = 0 ;
11107 PyObject * obj1 = 0 ;
11108 PyObject * obj2 = 0 ;
11109 char * kwnames[] = {
11110 (char *) "self",(char *) "fs",(char *) "location", NULL
11111 };
11112
11113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11115 if (!SWIG_IsOK(res1)) {
11116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11117 }
11118 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11119 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11120 if (!SWIG_IsOK(res2)) {
11121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11122 }
11123 if (!argp2) {
11124 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11125 }
11126 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11127 {
11128 arg3 = wxString_in_helper(obj2);
11129 if (arg3 == NULL) SWIG_fail;
11130 temp3 = true;
11131 }
11132 {
11133 PyThreadState* __tstate = wxPyBeginAllowThreads();
11134 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11135 wxPyEndAllowThreads(__tstate);
11136 if (PyErr_Occurred()) SWIG_fail;
11137 }
11138 {
11139 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11140 }
11141 {
11142 if (temp3)
11143 delete arg3;
11144 }
11145 return resultobj;
11146 fail:
11147 {
11148 if (temp3)
11149 delete arg3;
11150 }
11151 return NULL;
11152 }
11153
11154
11155 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11156 PyObject *resultobj = 0;
11157 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11158 wxString *arg2 = 0 ;
11159 int arg3 = (int) 0 ;
11160 wxString result;
11161 void *argp1 = 0 ;
11162 int res1 = 0 ;
11163 bool temp2 = false ;
11164 int val3 ;
11165 int ecode3 = 0 ;
11166 PyObject * obj0 = 0 ;
11167 PyObject * obj1 = 0 ;
11168 PyObject * obj2 = 0 ;
11169 char * kwnames[] = {
11170 (char *) "self",(char *) "spec",(char *) "flags", NULL
11171 };
11172
11173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11175 if (!SWIG_IsOK(res1)) {
11176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11177 }
11178 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11179 {
11180 arg2 = wxString_in_helper(obj1);
11181 if (arg2 == NULL) SWIG_fail;
11182 temp2 = true;
11183 }
11184 if (obj2) {
11185 ecode3 = SWIG_AsVal_int(obj2, &val3);
11186 if (!SWIG_IsOK(ecode3)) {
11187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11188 }
11189 arg3 = static_cast< int >(val3);
11190 }
11191 {
11192 PyThreadState* __tstate = wxPyBeginAllowThreads();
11193 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11194 wxPyEndAllowThreads(__tstate);
11195 if (PyErr_Occurred()) SWIG_fail;
11196 }
11197 {
11198 #if wxUSE_UNICODE
11199 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11200 #else
11201 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11202 #endif
11203 }
11204 {
11205 if (temp2)
11206 delete arg2;
11207 }
11208 return resultobj;
11209 fail:
11210 {
11211 if (temp2)
11212 delete arg2;
11213 }
11214 return NULL;
11215 }
11216
11217
11218 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11219 PyObject *resultobj = 0;
11220 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11221 wxString result;
11222 void *argp1 = 0 ;
11223 int res1 = 0 ;
11224 PyObject *swig_obj[1] ;
11225
11226 if (!args) SWIG_fail;
11227 swig_obj[0] = args;
11228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11229 if (!SWIG_IsOK(res1)) {
11230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11231 }
11232 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11233 {
11234 PyThreadState* __tstate = wxPyBeginAllowThreads();
11235 result = (arg1)->FindNext();
11236 wxPyEndAllowThreads(__tstate);
11237 if (PyErr_Occurred()) SWIG_fail;
11238 }
11239 {
11240 #if wxUSE_UNICODE
11241 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11242 #else
11243 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11244 #endif
11245 }
11246 return resultobj;
11247 fail:
11248 return NULL;
11249 }
11250
11251
11252 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11253 PyObject *obj;
11254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11255 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11256 return SWIG_Py_Void();
11257 }
11258
11259 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11260 return SWIG_Python_InitShadowInstance(args);
11261 }
11262
11263 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11264 PyObject *resultobj = 0;
11265 wxString *arg1 = 0 ;
11266 wxImage *arg2 = 0 ;
11267 long arg3 ;
11268 bool temp1 = false ;
11269 void *argp2 = 0 ;
11270 int res2 = 0 ;
11271 long val3 ;
11272 int ecode3 = 0 ;
11273 PyObject * obj0 = 0 ;
11274 PyObject * obj1 = 0 ;
11275 PyObject * obj2 = 0 ;
11276 char * kwnames[] = {
11277 (char *) "filename",(char *) "image",(char *) "type", NULL
11278 };
11279
11280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11281 {
11282 arg1 = wxString_in_helper(obj0);
11283 if (arg1 == NULL) SWIG_fail;
11284 temp1 = true;
11285 }
11286 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11287 if (!SWIG_IsOK(res2)) {
11288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11289 }
11290 if (!argp2) {
11291 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11292 }
11293 arg2 = reinterpret_cast< wxImage * >(argp2);
11294 ecode3 = SWIG_AsVal_long(obj2, &val3);
11295 if (!SWIG_IsOK(ecode3)) {
11296 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11297 }
11298 arg3 = static_cast< long >(val3);
11299 {
11300 PyThreadState* __tstate = wxPyBeginAllowThreads();
11301 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11302 wxPyEndAllowThreads(__tstate);
11303 if (PyErr_Occurred()) SWIG_fail;
11304 }
11305 resultobj = SWIG_Py_Void();
11306 {
11307 if (temp1)
11308 delete arg1;
11309 }
11310 return resultobj;
11311 fail:
11312 {
11313 if (temp1)
11314 delete arg1;
11315 }
11316 return NULL;
11317 }
11318
11319
11320 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11321 PyObject *resultobj = 0;
11322 wxString *arg1 = 0 ;
11323 wxBitmap *arg2 = 0 ;
11324 long arg3 ;
11325 bool temp1 = false ;
11326 void *argp2 = 0 ;
11327 int res2 = 0 ;
11328 long val3 ;
11329 int ecode3 = 0 ;
11330 PyObject * obj0 = 0 ;
11331 PyObject * obj1 = 0 ;
11332 PyObject * obj2 = 0 ;
11333 char * kwnames[] = {
11334 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11335 };
11336
11337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11338 {
11339 arg1 = wxString_in_helper(obj0);
11340 if (arg1 == NULL) SWIG_fail;
11341 temp1 = true;
11342 }
11343 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11344 if (!SWIG_IsOK(res2)) {
11345 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11346 }
11347 if (!argp2) {
11348 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11349 }
11350 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11351 ecode3 = SWIG_AsVal_long(obj2, &val3);
11352 if (!SWIG_IsOK(ecode3)) {
11353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11354 }
11355 arg3 = static_cast< long >(val3);
11356 {
11357 PyThreadState* __tstate = wxPyBeginAllowThreads();
11358 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11359 wxPyEndAllowThreads(__tstate);
11360 if (PyErr_Occurred()) SWIG_fail;
11361 }
11362 resultobj = SWIG_Py_Void();
11363 {
11364 if (temp1)
11365 delete arg1;
11366 }
11367 return resultobj;
11368 fail:
11369 {
11370 if (temp1)
11371 delete arg1;
11372 }
11373 return NULL;
11374 }
11375
11376
11377 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11378 PyObject *resultobj = 0;
11379 wxString *arg1 = 0 ;
11380 PyObject *arg2 = (PyObject *) 0 ;
11381 bool temp1 = false ;
11382 PyObject * obj0 = 0 ;
11383 PyObject * obj1 = 0 ;
11384 char * kwnames[] = {
11385 (char *) "filename",(char *) "data", NULL
11386 };
11387
11388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11389 {
11390 arg1 = wxString_in_helper(obj0);
11391 if (arg1 == NULL) SWIG_fail;
11392 temp1 = true;
11393 }
11394 arg2 = obj1;
11395 {
11396 PyThreadState* __tstate = wxPyBeginAllowThreads();
11397 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11398 wxPyEndAllowThreads(__tstate);
11399 if (PyErr_Occurred()) SWIG_fail;
11400 }
11401 resultobj = SWIG_Py_Void();
11402 {
11403 if (temp1)
11404 delete arg1;
11405 }
11406 return resultobj;
11407 fail:
11408 {
11409 if (temp1)
11410 delete arg1;
11411 }
11412 return NULL;
11413 }
11414
11415
11416 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11417 PyObject *resultobj = 0;
11418 wxMemoryFSHandler *result = 0 ;
11419
11420 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11421 {
11422 PyThreadState* __tstate = wxPyBeginAllowThreads();
11423 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11424 wxPyEndAllowThreads(__tstate);
11425 if (PyErr_Occurred()) SWIG_fail;
11426 }
11427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11428 return resultobj;
11429 fail:
11430 return NULL;
11431 }
11432
11433
11434 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11435 PyObject *resultobj = 0;
11436 wxString *arg1 = 0 ;
11437 bool temp1 = false ;
11438 PyObject * obj0 = 0 ;
11439 char * kwnames[] = {
11440 (char *) "filename", NULL
11441 };
11442
11443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11444 {
11445 arg1 = wxString_in_helper(obj0);
11446 if (arg1 == NULL) SWIG_fail;
11447 temp1 = true;
11448 }
11449 {
11450 PyThreadState* __tstate = wxPyBeginAllowThreads();
11451 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11452 wxPyEndAllowThreads(__tstate);
11453 if (PyErr_Occurred()) SWIG_fail;
11454 }
11455 resultobj = SWIG_Py_Void();
11456 {
11457 if (temp1)
11458 delete arg1;
11459 }
11460 return resultobj;
11461 fail:
11462 {
11463 if (temp1)
11464 delete arg1;
11465 }
11466 return NULL;
11467 }
11468
11469
11470 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11471 PyObject *resultobj = 0;
11472 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11473 wxString *arg2 = 0 ;
11474 bool result;
11475 void *argp1 = 0 ;
11476 int res1 = 0 ;
11477 bool temp2 = false ;
11478 PyObject * obj0 = 0 ;
11479 PyObject * obj1 = 0 ;
11480 char * kwnames[] = {
11481 (char *) "self",(char *) "location", NULL
11482 };
11483
11484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11486 if (!SWIG_IsOK(res1)) {
11487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11488 }
11489 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11490 {
11491 arg2 = wxString_in_helper(obj1);
11492 if (arg2 == NULL) SWIG_fail;
11493 temp2 = true;
11494 }
11495 {
11496 PyThreadState* __tstate = wxPyBeginAllowThreads();
11497 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11498 wxPyEndAllowThreads(__tstate);
11499 if (PyErr_Occurred()) SWIG_fail;
11500 }
11501 {
11502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11503 }
11504 {
11505 if (temp2)
11506 delete arg2;
11507 }
11508 return resultobj;
11509 fail:
11510 {
11511 if (temp2)
11512 delete arg2;
11513 }
11514 return NULL;
11515 }
11516
11517
11518 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11519 PyObject *resultobj = 0;
11520 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11521 wxFileSystem *arg2 = 0 ;
11522 wxString *arg3 = 0 ;
11523 wxFSFile *result = 0 ;
11524 void *argp1 = 0 ;
11525 int res1 = 0 ;
11526 void *argp2 = 0 ;
11527 int res2 = 0 ;
11528 bool temp3 = false ;
11529 PyObject * obj0 = 0 ;
11530 PyObject * obj1 = 0 ;
11531 PyObject * obj2 = 0 ;
11532 char * kwnames[] = {
11533 (char *) "self",(char *) "fs",(char *) "location", NULL
11534 };
11535
11536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11538 if (!SWIG_IsOK(res1)) {
11539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11540 }
11541 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11542 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11543 if (!SWIG_IsOK(res2)) {
11544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11545 }
11546 if (!argp2) {
11547 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11548 }
11549 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11550 {
11551 arg3 = wxString_in_helper(obj2);
11552 if (arg3 == NULL) SWIG_fail;
11553 temp3 = true;
11554 }
11555 {
11556 PyThreadState* __tstate = wxPyBeginAllowThreads();
11557 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11558 wxPyEndAllowThreads(__tstate);
11559 if (PyErr_Occurred()) SWIG_fail;
11560 }
11561 {
11562 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11563 }
11564 {
11565 if (temp3)
11566 delete arg3;
11567 }
11568 return resultobj;
11569 fail:
11570 {
11571 if (temp3)
11572 delete arg3;
11573 }
11574 return NULL;
11575 }
11576
11577
11578 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11579 PyObject *resultobj = 0;
11580 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11581 wxString *arg2 = 0 ;
11582 int arg3 = (int) 0 ;
11583 wxString result;
11584 void *argp1 = 0 ;
11585 int res1 = 0 ;
11586 bool temp2 = false ;
11587 int val3 ;
11588 int ecode3 = 0 ;
11589 PyObject * obj0 = 0 ;
11590 PyObject * obj1 = 0 ;
11591 PyObject * obj2 = 0 ;
11592 char * kwnames[] = {
11593 (char *) "self",(char *) "spec",(char *) "flags", NULL
11594 };
11595
11596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11598 if (!SWIG_IsOK(res1)) {
11599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11600 }
11601 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11602 {
11603 arg2 = wxString_in_helper(obj1);
11604 if (arg2 == NULL) SWIG_fail;
11605 temp2 = true;
11606 }
11607 if (obj2) {
11608 ecode3 = SWIG_AsVal_int(obj2, &val3);
11609 if (!SWIG_IsOK(ecode3)) {
11610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11611 }
11612 arg3 = static_cast< int >(val3);
11613 }
11614 {
11615 PyThreadState* __tstate = wxPyBeginAllowThreads();
11616 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11617 wxPyEndAllowThreads(__tstate);
11618 if (PyErr_Occurred()) SWIG_fail;
11619 }
11620 {
11621 #if wxUSE_UNICODE
11622 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11623 #else
11624 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11625 #endif
11626 }
11627 {
11628 if (temp2)
11629 delete arg2;
11630 }
11631 return resultobj;
11632 fail:
11633 {
11634 if (temp2)
11635 delete arg2;
11636 }
11637 return NULL;
11638 }
11639
11640
11641 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11642 PyObject *resultobj = 0;
11643 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11644 wxString result;
11645 void *argp1 = 0 ;
11646 int res1 = 0 ;
11647 PyObject *swig_obj[1] ;
11648
11649 if (!args) SWIG_fail;
11650 swig_obj[0] = args;
11651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11652 if (!SWIG_IsOK(res1)) {
11653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11654 }
11655 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11656 {
11657 PyThreadState* __tstate = wxPyBeginAllowThreads();
11658 result = (arg1)->FindNext();
11659 wxPyEndAllowThreads(__tstate);
11660 if (PyErr_Occurred()) SWIG_fail;
11661 }
11662 {
11663 #if wxUSE_UNICODE
11664 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11665 #else
11666 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11667 #endif
11668 }
11669 return resultobj;
11670 fail:
11671 return NULL;
11672 }
11673
11674
11675 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11676 PyObject *obj;
11677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11678 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11679 return SWIG_Py_Void();
11680 }
11681
11682 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11683 return SWIG_Python_InitShadowInstance(args);
11684 }
11685
11686 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11687 PyObject *resultobj = 0;
11688 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11689 wxString result;
11690 void *argp1 = 0 ;
11691 int res1 = 0 ;
11692 PyObject *swig_obj[1] ;
11693
11694 if (!args) SWIG_fail;
11695 swig_obj[0] = args;
11696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11697 if (!SWIG_IsOK(res1)) {
11698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11699 }
11700 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11701 {
11702 PyThreadState* __tstate = wxPyBeginAllowThreads();
11703 result = (arg1)->GetName();
11704 wxPyEndAllowThreads(__tstate);
11705 if (PyErr_Occurred()) SWIG_fail;
11706 }
11707 {
11708 #if wxUSE_UNICODE
11709 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11710 #else
11711 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11712 #endif
11713 }
11714 return resultobj;
11715 fail:
11716 return NULL;
11717 }
11718
11719
11720 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11721 PyObject *resultobj = 0;
11722 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11723 wxString result;
11724 void *argp1 = 0 ;
11725 int res1 = 0 ;
11726 PyObject *swig_obj[1] ;
11727
11728 if (!args) SWIG_fail;
11729 swig_obj[0] = args;
11730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11731 if (!SWIG_IsOK(res1)) {
11732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11733 }
11734 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11735 {
11736 PyThreadState* __tstate = wxPyBeginAllowThreads();
11737 result = (arg1)->GetExtension();
11738 wxPyEndAllowThreads(__tstate);
11739 if (PyErr_Occurred()) SWIG_fail;
11740 }
11741 {
11742 #if wxUSE_UNICODE
11743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11744 #else
11745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11746 #endif
11747 }
11748 return resultobj;
11749 fail:
11750 return NULL;
11751 }
11752
11753
11754 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11755 PyObject *resultobj = 0;
11756 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11757 long result;
11758 void *argp1 = 0 ;
11759 int res1 = 0 ;
11760 PyObject *swig_obj[1] ;
11761
11762 if (!args) SWIG_fail;
11763 swig_obj[0] = args;
11764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11765 if (!SWIG_IsOK(res1)) {
11766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11767 }
11768 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11769 {
11770 PyThreadState* __tstate = wxPyBeginAllowThreads();
11771 result = (long)(arg1)->GetType();
11772 wxPyEndAllowThreads(__tstate);
11773 if (PyErr_Occurred()) SWIG_fail;
11774 }
11775 resultobj = SWIG_From_long(static_cast< long >(result));
11776 return resultobj;
11777 fail:
11778 return NULL;
11779 }
11780
11781
11782 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11783 PyObject *resultobj = 0;
11784 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11785 wxString result;
11786 void *argp1 = 0 ;
11787 int res1 = 0 ;
11788 PyObject *swig_obj[1] ;
11789
11790 if (!args) SWIG_fail;
11791 swig_obj[0] = args;
11792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11793 if (!SWIG_IsOK(res1)) {
11794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11795 }
11796 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11797 {
11798 PyThreadState* __tstate = wxPyBeginAllowThreads();
11799 result = (arg1)->GetMimeType();
11800 wxPyEndAllowThreads(__tstate);
11801 if (PyErr_Occurred()) SWIG_fail;
11802 }
11803 {
11804 #if wxUSE_UNICODE
11805 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11806 #else
11807 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11808 #endif
11809 }
11810 return resultobj;
11811 fail:
11812 return NULL;
11813 }
11814
11815
11816 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11817 PyObject *resultobj = 0;
11818 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11819 wxString *arg2 = 0 ;
11820 bool result;
11821 void *argp1 = 0 ;
11822 int res1 = 0 ;
11823 bool temp2 = false ;
11824 PyObject * obj0 = 0 ;
11825 PyObject * obj1 = 0 ;
11826 char * kwnames[] = {
11827 (char *) "self",(char *) "name", NULL
11828 };
11829
11830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11832 if (!SWIG_IsOK(res1)) {
11833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11834 }
11835 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11836 {
11837 arg2 = wxString_in_helper(obj1);
11838 if (arg2 == NULL) SWIG_fail;
11839 temp2 = true;
11840 }
11841 {
11842 PyThreadState* __tstate = wxPyBeginAllowThreads();
11843 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11844 wxPyEndAllowThreads(__tstate);
11845 if (PyErr_Occurred()) SWIG_fail;
11846 }
11847 {
11848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11849 }
11850 {
11851 if (temp2)
11852 delete arg2;
11853 }
11854 return resultobj;
11855 fail:
11856 {
11857 if (temp2)
11858 delete arg2;
11859 }
11860 return NULL;
11861 }
11862
11863
11864 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11865 PyObject *resultobj = 0;
11866 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11867 wxInputStream *arg2 = 0 ;
11868 bool result;
11869 void *argp1 = 0 ;
11870 int res1 = 0 ;
11871 wxPyInputStream *temp2 ;
11872 bool created2 ;
11873 PyObject * obj0 = 0 ;
11874 PyObject * obj1 = 0 ;
11875 char * kwnames[] = {
11876 (char *) "self",(char *) "stream", NULL
11877 };
11878
11879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11881 if (!SWIG_IsOK(res1)) {
11882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11883 }
11884 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11885 {
11886 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11887 arg2 = temp2->m_wxis;
11888 created2 = false;
11889 } else {
11890 PyErr_Clear(); // clear the failure of the wxPyConvert above
11891 arg2 = wxPyCBInputStream_create(obj1, false);
11892 if (arg2 == NULL) {
11893 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11894 SWIG_fail;
11895 }
11896 created2 = true;
11897 }
11898 }
11899 {
11900 PyThreadState* __tstate = wxPyBeginAllowThreads();
11901 result = (bool)(arg1)->CanRead(*arg2);
11902 wxPyEndAllowThreads(__tstate);
11903 if (PyErr_Occurred()) SWIG_fail;
11904 }
11905 {
11906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11907 }
11908 {
11909 if (created2) delete arg2;
11910 }
11911 return resultobj;
11912 fail:
11913 {
11914 if (created2) delete arg2;
11915 }
11916 return NULL;
11917 }
11918
11919
11920 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11921 PyObject *resultobj = 0;
11922 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11923 wxString *arg2 = 0 ;
11924 void *argp1 = 0 ;
11925 int res1 = 0 ;
11926 bool temp2 = false ;
11927 PyObject * obj0 = 0 ;
11928 PyObject * obj1 = 0 ;
11929 char * kwnames[] = {
11930 (char *) "self",(char *) "name", NULL
11931 };
11932
11933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11935 if (!SWIG_IsOK(res1)) {
11936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11937 }
11938 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11939 {
11940 arg2 = wxString_in_helper(obj1);
11941 if (arg2 == NULL) SWIG_fail;
11942 temp2 = true;
11943 }
11944 {
11945 PyThreadState* __tstate = wxPyBeginAllowThreads();
11946 (arg1)->SetName((wxString const &)*arg2);
11947 wxPyEndAllowThreads(__tstate);
11948 if (PyErr_Occurred()) SWIG_fail;
11949 }
11950 resultobj = SWIG_Py_Void();
11951 {
11952 if (temp2)
11953 delete arg2;
11954 }
11955 return resultobj;
11956 fail:
11957 {
11958 if (temp2)
11959 delete arg2;
11960 }
11961 return NULL;
11962 }
11963
11964
11965 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11966 PyObject *resultobj = 0;
11967 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11968 wxString *arg2 = 0 ;
11969 void *argp1 = 0 ;
11970 int res1 = 0 ;
11971 bool temp2 = false ;
11972 PyObject * obj0 = 0 ;
11973 PyObject * obj1 = 0 ;
11974 char * kwnames[] = {
11975 (char *) "self",(char *) "extension", NULL
11976 };
11977
11978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11980 if (!SWIG_IsOK(res1)) {
11981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11982 }
11983 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11984 {
11985 arg2 = wxString_in_helper(obj1);
11986 if (arg2 == NULL) SWIG_fail;
11987 temp2 = true;
11988 }
11989 {
11990 PyThreadState* __tstate = wxPyBeginAllowThreads();
11991 (arg1)->SetExtension((wxString const &)*arg2);
11992 wxPyEndAllowThreads(__tstate);
11993 if (PyErr_Occurred()) SWIG_fail;
11994 }
11995 resultobj = SWIG_Py_Void();
11996 {
11997 if (temp2)
11998 delete arg2;
11999 }
12000 return resultobj;
12001 fail:
12002 {
12003 if (temp2)
12004 delete arg2;
12005 }
12006 return NULL;
12007 }
12008
12009
12010 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12011 PyObject *resultobj = 0;
12012 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12013 long arg2 ;
12014 void *argp1 = 0 ;
12015 int res1 = 0 ;
12016 long val2 ;
12017 int ecode2 = 0 ;
12018 PyObject * obj0 = 0 ;
12019 PyObject * obj1 = 0 ;
12020 char * kwnames[] = {
12021 (char *) "self",(char *) "type", NULL
12022 };
12023
12024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12026 if (!SWIG_IsOK(res1)) {
12027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12028 }
12029 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12030 ecode2 = SWIG_AsVal_long(obj1, &val2);
12031 if (!SWIG_IsOK(ecode2)) {
12032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12033 }
12034 arg2 = static_cast< long >(val2);
12035 {
12036 PyThreadState* __tstate = wxPyBeginAllowThreads();
12037 (arg1)->SetType(arg2);
12038 wxPyEndAllowThreads(__tstate);
12039 if (PyErr_Occurred()) SWIG_fail;
12040 }
12041 resultobj = SWIG_Py_Void();
12042 return resultobj;
12043 fail:
12044 return NULL;
12045 }
12046
12047
12048 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12049 PyObject *resultobj = 0;
12050 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12051 wxString *arg2 = 0 ;
12052 void *argp1 = 0 ;
12053 int res1 = 0 ;
12054 bool temp2 = false ;
12055 PyObject * obj0 = 0 ;
12056 PyObject * obj1 = 0 ;
12057 char * kwnames[] = {
12058 (char *) "self",(char *) "mimetype", NULL
12059 };
12060
12061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12063 if (!SWIG_IsOK(res1)) {
12064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12065 }
12066 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12067 {
12068 arg2 = wxString_in_helper(obj1);
12069 if (arg2 == NULL) SWIG_fail;
12070 temp2 = true;
12071 }
12072 {
12073 PyThreadState* __tstate = wxPyBeginAllowThreads();
12074 (arg1)->SetMimeType((wxString const &)*arg2);
12075 wxPyEndAllowThreads(__tstate);
12076 if (PyErr_Occurred()) SWIG_fail;
12077 }
12078 resultobj = SWIG_Py_Void();
12079 {
12080 if (temp2)
12081 delete arg2;
12082 }
12083 return resultobj;
12084 fail:
12085 {
12086 if (temp2)
12087 delete arg2;
12088 }
12089 return NULL;
12090 }
12091
12092
12093 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12094 PyObject *obj;
12095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12096 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12097 return SWIG_Py_Void();
12098 }
12099
12100 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12101 PyObject *resultobj = 0;
12102 wxPyImageHandler *result = 0 ;
12103
12104 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12105 {
12106 PyThreadState* __tstate = wxPyBeginAllowThreads();
12107 result = (wxPyImageHandler *)new wxPyImageHandler();
12108 wxPyEndAllowThreads(__tstate);
12109 if (PyErr_Occurred()) SWIG_fail;
12110 }
12111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12112 return resultobj;
12113 fail:
12114 return NULL;
12115 }
12116
12117
12118 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12119 PyObject *resultobj = 0;
12120 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12121 PyObject *arg2 = (PyObject *) 0 ;
12122 void *argp1 = 0 ;
12123 int res1 = 0 ;
12124 PyObject * obj0 = 0 ;
12125 PyObject * obj1 = 0 ;
12126 char * kwnames[] = {
12127 (char *) "self",(char *) "self", NULL
12128 };
12129
12130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12132 if (!SWIG_IsOK(res1)) {
12133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12134 }
12135 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12136 arg2 = obj1;
12137 {
12138 PyThreadState* __tstate = wxPyBeginAllowThreads();
12139 (arg1)->_SetSelf(arg2);
12140 wxPyEndAllowThreads(__tstate);
12141 if (PyErr_Occurred()) SWIG_fail;
12142 }
12143 resultobj = SWIG_Py_Void();
12144 return resultobj;
12145 fail:
12146 return NULL;
12147 }
12148
12149
12150 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12151 PyObject *obj;
12152 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12153 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12154 return SWIG_Py_Void();
12155 }
12156
12157 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12158 return SWIG_Python_InitShadowInstance(args);
12159 }
12160
12161 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12162 PyObject *resultobj = 0;
12163 wxImageHistogram *result = 0 ;
12164
12165 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12166 {
12167 PyThreadState* __tstate = wxPyBeginAllowThreads();
12168 result = (wxImageHistogram *)new wxImageHistogram();
12169 wxPyEndAllowThreads(__tstate);
12170 if (PyErr_Occurred()) SWIG_fail;
12171 }
12172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12173 return resultobj;
12174 fail:
12175 return NULL;
12176 }
12177
12178
12179 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12180 PyObject *resultobj = 0;
12181 byte arg1 ;
12182 byte arg2 ;
12183 byte arg3 ;
12184 unsigned long result;
12185 unsigned char val1 ;
12186 int ecode1 = 0 ;
12187 unsigned char val2 ;
12188 int ecode2 = 0 ;
12189 unsigned char val3 ;
12190 int ecode3 = 0 ;
12191 PyObject * obj0 = 0 ;
12192 PyObject * obj1 = 0 ;
12193 PyObject * obj2 = 0 ;
12194 char * kwnames[] = {
12195 (char *) "r",(char *) "g",(char *) "b", NULL
12196 };
12197
12198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12199 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12200 if (!SWIG_IsOK(ecode1)) {
12201 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12202 }
12203 arg1 = static_cast< byte >(val1);
12204 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12205 if (!SWIG_IsOK(ecode2)) {
12206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12207 }
12208 arg2 = static_cast< byte >(val2);
12209 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12210 if (!SWIG_IsOK(ecode3)) {
12211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12212 }
12213 arg3 = static_cast< byte >(val3);
12214 {
12215 PyThreadState* __tstate = wxPyBeginAllowThreads();
12216 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12217 wxPyEndAllowThreads(__tstate);
12218 if (PyErr_Occurred()) SWIG_fail;
12219 }
12220 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12221 return resultobj;
12222 fail:
12223 return NULL;
12224 }
12225
12226
12227 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12228 PyObject *resultobj = 0;
12229 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12230 byte *arg2 = (byte *) 0 ;
12231 byte *arg3 = (byte *) 0 ;
12232 byte *arg4 = (byte *) 0 ;
12233 byte arg5 = (byte) 1 ;
12234 byte arg6 = (byte) 0 ;
12235 byte arg7 = (byte) 0 ;
12236 bool result;
12237 void *argp1 = 0 ;
12238 int res1 = 0 ;
12239 byte temp2 ;
12240 int res2 = SWIG_TMPOBJ ;
12241 byte temp3 ;
12242 int res3 = SWIG_TMPOBJ ;
12243 byte temp4 ;
12244 int res4 = SWIG_TMPOBJ ;
12245 unsigned char val5 ;
12246 int ecode5 = 0 ;
12247 unsigned char val6 ;
12248 int ecode6 = 0 ;
12249 unsigned char val7 ;
12250 int ecode7 = 0 ;
12251 PyObject * obj0 = 0 ;
12252 PyObject * obj1 = 0 ;
12253 PyObject * obj2 = 0 ;
12254 PyObject * obj3 = 0 ;
12255 char * kwnames[] = {
12256 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12257 };
12258
12259 arg2 = &temp2;
12260 arg3 = &temp3;
12261 arg4 = &temp4;
12262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12264 if (!SWIG_IsOK(res1)) {
12265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12266 }
12267 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12268 if (obj1) {
12269 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12270 if (!SWIG_IsOK(ecode5)) {
12271 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12272 }
12273 arg5 = static_cast< byte >(val5);
12274 }
12275 if (obj2) {
12276 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12277 if (!SWIG_IsOK(ecode6)) {
12278 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12279 }
12280 arg6 = static_cast< byte >(val6);
12281 }
12282 if (obj3) {
12283 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12284 if (!SWIG_IsOK(ecode7)) {
12285 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12286 }
12287 arg7 = static_cast< byte >(val7);
12288 }
12289 {
12290 PyThreadState* __tstate = wxPyBeginAllowThreads();
12291 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12292 wxPyEndAllowThreads(__tstate);
12293 if (PyErr_Occurred()) SWIG_fail;
12294 }
12295 {
12296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12297 }
12298 if (SWIG_IsTmpObj(res2)) {
12299 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12300 } else {
12301 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12302 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12303 }
12304 if (SWIG_IsTmpObj(res3)) {
12305 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12306 } else {
12307 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12308 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12309 }
12310 if (SWIG_IsTmpObj(res4)) {
12311 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12312 } else {
12313 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12314 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12315 }
12316 return resultobj;
12317 fail:
12318 return NULL;
12319 }
12320
12321
12322 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12323 PyObject *resultobj = 0;
12324 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12325 unsigned long arg2 ;
12326 unsigned long result;
12327 void *argp1 = 0 ;
12328 int res1 = 0 ;
12329 unsigned long val2 ;
12330 int ecode2 = 0 ;
12331 PyObject * obj0 = 0 ;
12332 PyObject * obj1 = 0 ;
12333 char * kwnames[] = {
12334 (char *) "self",(char *) "key", NULL
12335 };
12336
12337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12339 if (!SWIG_IsOK(res1)) {
12340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12341 }
12342 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12343 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12344 if (!SWIG_IsOK(ecode2)) {
12345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12346 }
12347 arg2 = static_cast< unsigned long >(val2);
12348 {
12349 PyThreadState* __tstate = wxPyBeginAllowThreads();
12350 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12351 wxPyEndAllowThreads(__tstate);
12352 if (PyErr_Occurred()) SWIG_fail;
12353 }
12354 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12355 return resultobj;
12356 fail:
12357 return NULL;
12358 }
12359
12360
12361 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12362 PyObject *resultobj = 0;
12363 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12364 byte arg2 ;
12365 byte arg3 ;
12366 byte arg4 ;
12367 unsigned long result;
12368 void *argp1 = 0 ;
12369 int res1 = 0 ;
12370 unsigned char val2 ;
12371 int ecode2 = 0 ;
12372 unsigned char val3 ;
12373 int ecode3 = 0 ;
12374 unsigned char val4 ;
12375 int ecode4 = 0 ;
12376 PyObject * obj0 = 0 ;
12377 PyObject * obj1 = 0 ;
12378 PyObject * obj2 = 0 ;
12379 PyObject * obj3 = 0 ;
12380 char * kwnames[] = {
12381 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12382 };
12383
12384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12386 if (!SWIG_IsOK(res1)) {
12387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12388 }
12389 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12390 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12391 if (!SWIG_IsOK(ecode2)) {
12392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12393 }
12394 arg2 = static_cast< byte >(val2);
12395 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12396 if (!SWIG_IsOK(ecode3)) {
12397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12398 }
12399 arg3 = static_cast< byte >(val3);
12400 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12401 if (!SWIG_IsOK(ecode4)) {
12402 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12403 }
12404 arg4 = static_cast< byte >(val4);
12405 {
12406 PyThreadState* __tstate = wxPyBeginAllowThreads();
12407 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12408 wxPyEndAllowThreads(__tstate);
12409 if (PyErr_Occurred()) SWIG_fail;
12410 }
12411 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12412 return resultobj;
12413 fail:
12414 return NULL;
12415 }
12416
12417
12418 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12419 PyObject *resultobj = 0;
12420 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12421 wxColour *arg2 = 0 ;
12422 unsigned long result;
12423 void *argp1 = 0 ;
12424 int res1 = 0 ;
12425 wxColour temp2 ;
12426 PyObject * obj0 = 0 ;
12427 PyObject * obj1 = 0 ;
12428 char * kwnames[] = {
12429 (char *) "self",(char *) "colour", NULL
12430 };
12431
12432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12434 if (!SWIG_IsOK(res1)) {
12435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12436 }
12437 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12438 {
12439 arg2 = &temp2;
12440 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12441 }
12442 {
12443 PyThreadState* __tstate = wxPyBeginAllowThreads();
12444 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12445 wxPyEndAllowThreads(__tstate);
12446 if (PyErr_Occurred()) SWIG_fail;
12447 }
12448 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12449 return resultobj;
12450 fail:
12451 return NULL;
12452 }
12453
12454
12455 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12456 PyObject *obj;
12457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12458 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12459 return SWIG_Py_Void();
12460 }
12461
12462 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12463 return SWIG_Python_InitShadowInstance(args);
12464 }
12465
12466 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12467 PyObject *resultobj = 0;
12468 byte arg1 = (byte) 0 ;
12469 byte arg2 = (byte) 0 ;
12470 byte arg3 = (byte) 0 ;
12471 wxImage_RGBValue *result = 0 ;
12472 unsigned char val1 ;
12473 int ecode1 = 0 ;
12474 unsigned char val2 ;
12475 int ecode2 = 0 ;
12476 unsigned char val3 ;
12477 int ecode3 = 0 ;
12478 PyObject * obj0 = 0 ;
12479 PyObject * obj1 = 0 ;
12480 PyObject * obj2 = 0 ;
12481 char * kwnames[] = {
12482 (char *) "r",(char *) "g",(char *) "b", NULL
12483 };
12484
12485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12486 if (obj0) {
12487 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12488 if (!SWIG_IsOK(ecode1)) {
12489 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12490 }
12491 arg1 = static_cast< byte >(val1);
12492 }
12493 if (obj1) {
12494 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12495 if (!SWIG_IsOK(ecode2)) {
12496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12497 }
12498 arg2 = static_cast< byte >(val2);
12499 }
12500 if (obj2) {
12501 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12502 if (!SWIG_IsOK(ecode3)) {
12503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12504 }
12505 arg3 = static_cast< byte >(val3);
12506 }
12507 {
12508 PyThreadState* __tstate = wxPyBeginAllowThreads();
12509 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12510 wxPyEndAllowThreads(__tstate);
12511 if (PyErr_Occurred()) SWIG_fail;
12512 }
12513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12514 return resultobj;
12515 fail:
12516 return NULL;
12517 }
12518
12519
12520 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12521 PyObject *resultobj = 0;
12522 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12523 byte arg2 ;
12524 void *argp1 = 0 ;
12525 int res1 = 0 ;
12526 unsigned char val2 ;
12527 int ecode2 = 0 ;
12528 PyObject *swig_obj[2] ;
12529
12530 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12532 if (!SWIG_IsOK(res1)) {
12533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12534 }
12535 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12536 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12537 if (!SWIG_IsOK(ecode2)) {
12538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12539 }
12540 arg2 = static_cast< byte >(val2);
12541 if (arg1) (arg1)->red = arg2;
12542
12543 resultobj = SWIG_Py_Void();
12544 return resultobj;
12545 fail:
12546 return NULL;
12547 }
12548
12549
12550 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12551 PyObject *resultobj = 0;
12552 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12553 byte result;
12554 void *argp1 = 0 ;
12555 int res1 = 0 ;
12556 PyObject *swig_obj[1] ;
12557
12558 if (!args) SWIG_fail;
12559 swig_obj[0] = args;
12560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12561 if (!SWIG_IsOK(res1)) {
12562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12563 }
12564 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12565 result = (byte) ((arg1)->red);
12566 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12567 return resultobj;
12568 fail:
12569 return NULL;
12570 }
12571
12572
12573 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12574 PyObject *resultobj = 0;
12575 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12576 byte arg2 ;
12577 void *argp1 = 0 ;
12578 int res1 = 0 ;
12579 unsigned char val2 ;
12580 int ecode2 = 0 ;
12581 PyObject *swig_obj[2] ;
12582
12583 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12585 if (!SWIG_IsOK(res1)) {
12586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12587 }
12588 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12589 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12590 if (!SWIG_IsOK(ecode2)) {
12591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12592 }
12593 arg2 = static_cast< byte >(val2);
12594 if (arg1) (arg1)->green = arg2;
12595
12596 resultobj = SWIG_Py_Void();
12597 return resultobj;
12598 fail:
12599 return NULL;
12600 }
12601
12602
12603 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12604 PyObject *resultobj = 0;
12605 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12606 byte result;
12607 void *argp1 = 0 ;
12608 int res1 = 0 ;
12609 PyObject *swig_obj[1] ;
12610
12611 if (!args) SWIG_fail;
12612 swig_obj[0] = args;
12613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12614 if (!SWIG_IsOK(res1)) {
12615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12616 }
12617 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12618 result = (byte) ((arg1)->green);
12619 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12620 return resultobj;
12621 fail:
12622 return NULL;
12623 }
12624
12625
12626 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12627 PyObject *resultobj = 0;
12628 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12629 byte arg2 ;
12630 void *argp1 = 0 ;
12631 int res1 = 0 ;
12632 unsigned char val2 ;
12633 int ecode2 = 0 ;
12634 PyObject *swig_obj[2] ;
12635
12636 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12638 if (!SWIG_IsOK(res1)) {
12639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12640 }
12641 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12642 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12643 if (!SWIG_IsOK(ecode2)) {
12644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12645 }
12646 arg2 = static_cast< byte >(val2);
12647 if (arg1) (arg1)->blue = arg2;
12648
12649 resultobj = SWIG_Py_Void();
12650 return resultobj;
12651 fail:
12652 return NULL;
12653 }
12654
12655
12656 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12657 PyObject *resultobj = 0;
12658 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12659 byte result;
12660 void *argp1 = 0 ;
12661 int res1 = 0 ;
12662 PyObject *swig_obj[1] ;
12663
12664 if (!args) SWIG_fail;
12665 swig_obj[0] = args;
12666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12667 if (!SWIG_IsOK(res1)) {
12668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12669 }
12670 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12671 result = (byte) ((arg1)->blue);
12672 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12673 return resultobj;
12674 fail:
12675 return NULL;
12676 }
12677
12678
12679 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12680 PyObject *obj;
12681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12682 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12683 return SWIG_Py_Void();
12684 }
12685
12686 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12687 return SWIG_Python_InitShadowInstance(args);
12688 }
12689
12690 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12691 PyObject *resultobj = 0;
12692 double arg1 = (double) 0.0 ;
12693 double arg2 = (double) 0.0 ;
12694 double arg3 = (double) 0.0 ;
12695 wxImage_HSVValue *result = 0 ;
12696 double val1 ;
12697 int ecode1 = 0 ;
12698 double val2 ;
12699 int ecode2 = 0 ;
12700 double val3 ;
12701 int ecode3 = 0 ;
12702 PyObject * obj0 = 0 ;
12703 PyObject * obj1 = 0 ;
12704 PyObject * obj2 = 0 ;
12705 char * kwnames[] = {
12706 (char *) "h",(char *) "s",(char *) "v", NULL
12707 };
12708
12709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12710 if (obj0) {
12711 ecode1 = SWIG_AsVal_double(obj0, &val1);
12712 if (!SWIG_IsOK(ecode1)) {
12713 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12714 }
12715 arg1 = static_cast< double >(val1);
12716 }
12717 if (obj1) {
12718 ecode2 = SWIG_AsVal_double(obj1, &val2);
12719 if (!SWIG_IsOK(ecode2)) {
12720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12721 }
12722 arg2 = static_cast< double >(val2);
12723 }
12724 if (obj2) {
12725 ecode3 = SWIG_AsVal_double(obj2, &val3);
12726 if (!SWIG_IsOK(ecode3)) {
12727 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12728 }
12729 arg3 = static_cast< double >(val3);
12730 }
12731 {
12732 PyThreadState* __tstate = wxPyBeginAllowThreads();
12733 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12734 wxPyEndAllowThreads(__tstate);
12735 if (PyErr_Occurred()) SWIG_fail;
12736 }
12737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12738 return resultobj;
12739 fail:
12740 return NULL;
12741 }
12742
12743
12744 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12745 PyObject *resultobj = 0;
12746 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12747 double arg2 ;
12748 void *argp1 = 0 ;
12749 int res1 = 0 ;
12750 double val2 ;
12751 int ecode2 = 0 ;
12752 PyObject *swig_obj[2] ;
12753
12754 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12756 if (!SWIG_IsOK(res1)) {
12757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12758 }
12759 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12760 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12761 if (!SWIG_IsOK(ecode2)) {
12762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12763 }
12764 arg2 = static_cast< double >(val2);
12765 if (arg1) (arg1)->hue = arg2;
12766
12767 resultobj = SWIG_Py_Void();
12768 return resultobj;
12769 fail:
12770 return NULL;
12771 }
12772
12773
12774 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12775 PyObject *resultobj = 0;
12776 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12777 double result;
12778 void *argp1 = 0 ;
12779 int res1 = 0 ;
12780 PyObject *swig_obj[1] ;
12781
12782 if (!args) SWIG_fail;
12783 swig_obj[0] = args;
12784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12785 if (!SWIG_IsOK(res1)) {
12786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12787 }
12788 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12789 result = (double) ((arg1)->hue);
12790 resultobj = SWIG_From_double(static_cast< double >(result));
12791 return resultobj;
12792 fail:
12793 return NULL;
12794 }
12795
12796
12797 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12798 PyObject *resultobj = 0;
12799 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12800 double arg2 ;
12801 void *argp1 = 0 ;
12802 int res1 = 0 ;
12803 double val2 ;
12804 int ecode2 = 0 ;
12805 PyObject *swig_obj[2] ;
12806
12807 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12809 if (!SWIG_IsOK(res1)) {
12810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12811 }
12812 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12813 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12814 if (!SWIG_IsOK(ecode2)) {
12815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12816 }
12817 arg2 = static_cast< double >(val2);
12818 if (arg1) (arg1)->saturation = arg2;
12819
12820 resultobj = SWIG_Py_Void();
12821 return resultobj;
12822 fail:
12823 return NULL;
12824 }
12825
12826
12827 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12828 PyObject *resultobj = 0;
12829 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12830 double result;
12831 void *argp1 = 0 ;
12832 int res1 = 0 ;
12833 PyObject *swig_obj[1] ;
12834
12835 if (!args) SWIG_fail;
12836 swig_obj[0] = args;
12837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12838 if (!SWIG_IsOK(res1)) {
12839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12840 }
12841 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12842 result = (double) ((arg1)->saturation);
12843 resultobj = SWIG_From_double(static_cast< double >(result));
12844 return resultobj;
12845 fail:
12846 return NULL;
12847 }
12848
12849
12850 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12851 PyObject *resultobj = 0;
12852 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12853 double arg2 ;
12854 void *argp1 = 0 ;
12855 int res1 = 0 ;
12856 double val2 ;
12857 int ecode2 = 0 ;
12858 PyObject *swig_obj[2] ;
12859
12860 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12862 if (!SWIG_IsOK(res1)) {
12863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12864 }
12865 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12866 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12867 if (!SWIG_IsOK(ecode2)) {
12868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12869 }
12870 arg2 = static_cast< double >(val2);
12871 if (arg1) (arg1)->value = arg2;
12872
12873 resultobj = SWIG_Py_Void();
12874 return resultobj;
12875 fail:
12876 return NULL;
12877 }
12878
12879
12880 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12881 PyObject *resultobj = 0;
12882 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12883 double result;
12884 void *argp1 = 0 ;
12885 int res1 = 0 ;
12886 PyObject *swig_obj[1] ;
12887
12888 if (!args) SWIG_fail;
12889 swig_obj[0] = args;
12890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12891 if (!SWIG_IsOK(res1)) {
12892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12893 }
12894 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12895 result = (double) ((arg1)->value);
12896 resultobj = SWIG_From_double(static_cast< double >(result));
12897 return resultobj;
12898 fail:
12899 return NULL;
12900 }
12901
12902
12903 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12904 PyObject *obj;
12905 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12906 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12907 return SWIG_Py_Void();
12908 }
12909
12910 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12911 return SWIG_Python_InitShadowInstance(args);
12912 }
12913
12914 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12915 PyObject *resultobj = 0;
12916 wxString *arg1 = 0 ;
12917 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12918 int arg3 = (int) -1 ;
12919 wxImage *result = 0 ;
12920 bool temp1 = false ;
12921 long val2 ;
12922 int ecode2 = 0 ;
12923 int val3 ;
12924 int ecode3 = 0 ;
12925 PyObject * obj0 = 0 ;
12926 PyObject * obj1 = 0 ;
12927 PyObject * obj2 = 0 ;
12928 char * kwnames[] = {
12929 (char *) "name",(char *) "type",(char *) "index", NULL
12930 };
12931
12932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12933 {
12934 arg1 = wxString_in_helper(obj0);
12935 if (arg1 == NULL) SWIG_fail;
12936 temp1 = true;
12937 }
12938 if (obj1) {
12939 ecode2 = SWIG_AsVal_long(obj1, &val2);
12940 if (!SWIG_IsOK(ecode2)) {
12941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12942 }
12943 arg2 = static_cast< long >(val2);
12944 }
12945 if (obj2) {
12946 ecode3 = SWIG_AsVal_int(obj2, &val3);
12947 if (!SWIG_IsOK(ecode3)) {
12948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12949 }
12950 arg3 = static_cast< int >(val3);
12951 }
12952 {
12953 PyThreadState* __tstate = wxPyBeginAllowThreads();
12954 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12955 wxPyEndAllowThreads(__tstate);
12956 if (PyErr_Occurred()) SWIG_fail;
12957 }
12958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12959 {
12960 if (temp1)
12961 delete arg1;
12962 }
12963 return resultobj;
12964 fail:
12965 {
12966 if (temp1)
12967 delete arg1;
12968 }
12969 return NULL;
12970 }
12971
12972
12973 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12974 PyObject *resultobj = 0;
12975 wxImage *arg1 = (wxImage *) 0 ;
12976 void *argp1 = 0 ;
12977 int res1 = 0 ;
12978 PyObject *swig_obj[1] ;
12979
12980 if (!args) SWIG_fail;
12981 swig_obj[0] = args;
12982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12983 if (!SWIG_IsOK(res1)) {
12984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12985 }
12986 arg1 = reinterpret_cast< wxImage * >(argp1);
12987 {
12988 PyThreadState* __tstate = wxPyBeginAllowThreads();
12989 delete arg1;
12990
12991 wxPyEndAllowThreads(__tstate);
12992 if (PyErr_Occurred()) SWIG_fail;
12993 }
12994 resultobj = SWIG_Py_Void();
12995 return resultobj;
12996 fail:
12997 return NULL;
12998 }
12999
13000
13001 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13002 PyObject *resultobj = 0;
13003 wxString *arg1 = 0 ;
13004 wxString *arg2 = 0 ;
13005 int arg3 = (int) -1 ;
13006 wxImage *result = 0 ;
13007 bool temp1 = false ;
13008 bool temp2 = false ;
13009 int val3 ;
13010 int ecode3 = 0 ;
13011 PyObject * obj0 = 0 ;
13012 PyObject * obj1 = 0 ;
13013 PyObject * obj2 = 0 ;
13014 char * kwnames[] = {
13015 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13016 };
13017
13018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13019 {
13020 arg1 = wxString_in_helper(obj0);
13021 if (arg1 == NULL) SWIG_fail;
13022 temp1 = true;
13023 }
13024 {
13025 arg2 = wxString_in_helper(obj1);
13026 if (arg2 == NULL) SWIG_fail;
13027 temp2 = true;
13028 }
13029 if (obj2) {
13030 ecode3 = SWIG_AsVal_int(obj2, &val3);
13031 if (!SWIG_IsOK(ecode3)) {
13032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13033 }
13034 arg3 = static_cast< int >(val3);
13035 }
13036 {
13037 PyThreadState* __tstate = wxPyBeginAllowThreads();
13038 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13039 wxPyEndAllowThreads(__tstate);
13040 if (PyErr_Occurred()) SWIG_fail;
13041 }
13042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13043 {
13044 if (temp1)
13045 delete arg1;
13046 }
13047 {
13048 if (temp2)
13049 delete arg2;
13050 }
13051 return resultobj;
13052 fail:
13053 {
13054 if (temp1)
13055 delete arg1;
13056 }
13057 {
13058 if (temp2)
13059 delete arg2;
13060 }
13061 return NULL;
13062 }
13063
13064
13065 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13066 PyObject *resultobj = 0;
13067 wxInputStream *arg1 = 0 ;
13068 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13069 int arg3 = (int) -1 ;
13070 wxImage *result = 0 ;
13071 wxPyInputStream *temp1 ;
13072 bool created1 ;
13073 long val2 ;
13074 int ecode2 = 0 ;
13075 int val3 ;
13076 int ecode3 = 0 ;
13077 PyObject * obj0 = 0 ;
13078 PyObject * obj1 = 0 ;
13079 PyObject * obj2 = 0 ;
13080 char * kwnames[] = {
13081 (char *) "stream",(char *) "type",(char *) "index", NULL
13082 };
13083
13084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13085 {
13086 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13087 arg1 = temp1->m_wxis;
13088 created1 = false;
13089 } else {
13090 PyErr_Clear(); // clear the failure of the wxPyConvert above
13091 arg1 = wxPyCBInputStream_create(obj0, false);
13092 if (arg1 == NULL) {
13093 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13094 SWIG_fail;
13095 }
13096 created1 = true;
13097 }
13098 }
13099 if (obj1) {
13100 ecode2 = SWIG_AsVal_long(obj1, &val2);
13101 if (!SWIG_IsOK(ecode2)) {
13102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13103 }
13104 arg2 = static_cast< long >(val2);
13105 }
13106 if (obj2) {
13107 ecode3 = SWIG_AsVal_int(obj2, &val3);
13108 if (!SWIG_IsOK(ecode3)) {
13109 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13110 }
13111 arg3 = static_cast< int >(val3);
13112 }
13113 {
13114 PyThreadState* __tstate = wxPyBeginAllowThreads();
13115 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13116 wxPyEndAllowThreads(__tstate);
13117 if (PyErr_Occurred()) SWIG_fail;
13118 }
13119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13120 {
13121 if (created1) delete arg1;
13122 }
13123 return resultobj;
13124 fail:
13125 {
13126 if (created1) delete arg1;
13127 }
13128 return NULL;
13129 }
13130
13131
13132 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13133 PyObject *resultobj = 0;
13134 wxInputStream *arg1 = 0 ;
13135 wxString *arg2 = 0 ;
13136 int arg3 = (int) -1 ;
13137 wxImage *result = 0 ;
13138 wxPyInputStream *temp1 ;
13139 bool created1 ;
13140 bool temp2 = false ;
13141 int val3 ;
13142 int ecode3 = 0 ;
13143 PyObject * obj0 = 0 ;
13144 PyObject * obj1 = 0 ;
13145 PyObject * obj2 = 0 ;
13146 char * kwnames[] = {
13147 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13148 };
13149
13150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13151 {
13152 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13153 arg1 = temp1->m_wxis;
13154 created1 = false;
13155 } else {
13156 PyErr_Clear(); // clear the failure of the wxPyConvert above
13157 arg1 = wxPyCBInputStream_create(obj0, false);
13158 if (arg1 == NULL) {
13159 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13160 SWIG_fail;
13161 }
13162 created1 = true;
13163 }
13164 }
13165 {
13166 arg2 = wxString_in_helper(obj1);
13167 if (arg2 == NULL) SWIG_fail;
13168 temp2 = true;
13169 }
13170 if (obj2) {
13171 ecode3 = SWIG_AsVal_int(obj2, &val3);
13172 if (!SWIG_IsOK(ecode3)) {
13173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13174 }
13175 arg3 = static_cast< int >(val3);
13176 }
13177 {
13178 PyThreadState* __tstate = wxPyBeginAllowThreads();
13179 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13180 wxPyEndAllowThreads(__tstate);
13181 if (PyErr_Occurred()) SWIG_fail;
13182 }
13183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13184 {
13185 if (created1) delete arg1;
13186 }
13187 {
13188 if (temp2)
13189 delete arg2;
13190 }
13191 return resultobj;
13192 fail:
13193 {
13194 if (created1) delete arg1;
13195 }
13196 {
13197 if (temp2)
13198 delete arg2;
13199 }
13200 return NULL;
13201 }
13202
13203
13204 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13205 PyObject *resultobj = 0;
13206 int arg1 = (int) 0 ;
13207 int arg2 = (int) 0 ;
13208 bool arg3 = (bool) true ;
13209 wxImage *result = 0 ;
13210 int val1 ;
13211 int ecode1 = 0 ;
13212 int val2 ;
13213 int ecode2 = 0 ;
13214 bool val3 ;
13215 int ecode3 = 0 ;
13216 PyObject * obj0 = 0 ;
13217 PyObject * obj1 = 0 ;
13218 PyObject * obj2 = 0 ;
13219 char * kwnames[] = {
13220 (char *) "width",(char *) "height",(char *) "clear", NULL
13221 };
13222
13223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13224 if (obj0) {
13225 ecode1 = SWIG_AsVal_int(obj0, &val1);
13226 if (!SWIG_IsOK(ecode1)) {
13227 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13228 }
13229 arg1 = static_cast< int >(val1);
13230 }
13231 if (obj1) {
13232 ecode2 = SWIG_AsVal_int(obj1, &val2);
13233 if (!SWIG_IsOK(ecode2)) {
13234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13235 }
13236 arg2 = static_cast< int >(val2);
13237 }
13238 if (obj2) {
13239 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13240 if (!SWIG_IsOK(ecode3)) {
13241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13242 }
13243 arg3 = static_cast< bool >(val3);
13244 }
13245 {
13246 PyThreadState* __tstate = wxPyBeginAllowThreads();
13247 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13248 wxPyEndAllowThreads(__tstate);
13249 if (PyErr_Occurred()) SWIG_fail;
13250 }
13251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13252 return resultobj;
13253 fail:
13254 return NULL;
13255 }
13256
13257
13258 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13259 PyObject *resultobj = 0;
13260 wxBitmap *arg1 = 0 ;
13261 wxImage *result = 0 ;
13262 void *argp1 = 0 ;
13263 int res1 = 0 ;
13264 PyObject * obj0 = 0 ;
13265 char * kwnames[] = {
13266 (char *) "bitmap", NULL
13267 };
13268
13269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13270 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13271 if (!SWIG_IsOK(res1)) {
13272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13273 }
13274 if (!argp1) {
13275 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13276 }
13277 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13278 {
13279 if (!wxPyCheckForApp()) SWIG_fail;
13280 PyThreadState* __tstate = wxPyBeginAllowThreads();
13281 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13282 wxPyEndAllowThreads(__tstate);
13283 if (PyErr_Occurred()) SWIG_fail;
13284 }
13285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13286 return resultobj;
13287 fail:
13288 return NULL;
13289 }
13290
13291
13292 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13293 PyObject *resultobj = 0;
13294 int arg1 ;
13295 int arg2 ;
13296 buffer arg3 ;
13297 int arg4 ;
13298 wxImage *result = 0 ;
13299 int val1 ;
13300 int ecode1 = 0 ;
13301 int val2 ;
13302 int ecode2 = 0 ;
13303 PyObject * obj0 = 0 ;
13304 PyObject * obj1 = 0 ;
13305 PyObject * obj2 = 0 ;
13306 char * kwnames[] = {
13307 (char *) "width",(char *) "height",(char *) "data", NULL
13308 };
13309
13310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13311 ecode1 = SWIG_AsVal_int(obj0, &val1);
13312 if (!SWIG_IsOK(ecode1)) {
13313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13314 }
13315 arg1 = static_cast< int >(val1);
13316 ecode2 = SWIG_AsVal_int(obj1, &val2);
13317 if (!SWIG_IsOK(ecode2)) {
13318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13319 }
13320 arg2 = static_cast< int >(val2);
13321 {
13322 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13323 }
13324 {
13325 PyThreadState* __tstate = wxPyBeginAllowThreads();
13326 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13327 wxPyEndAllowThreads(__tstate);
13328 if (PyErr_Occurred()) SWIG_fail;
13329 }
13330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13331 return resultobj;
13332 fail:
13333 return NULL;
13334 }
13335
13336
13337 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13338 PyObject *resultobj = 0;
13339 int arg1 ;
13340 int arg2 ;
13341 buffer arg3 ;
13342 int arg4 ;
13343 buffer arg5 ;
13344 int arg6 ;
13345 wxImage *result = 0 ;
13346 int val1 ;
13347 int ecode1 = 0 ;
13348 int val2 ;
13349 int ecode2 = 0 ;
13350 PyObject * obj0 = 0 ;
13351 PyObject * obj1 = 0 ;
13352 PyObject * obj2 = 0 ;
13353 PyObject * obj3 = 0 ;
13354 char * kwnames[] = {
13355 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13356 };
13357
13358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13359 ecode1 = SWIG_AsVal_int(obj0, &val1);
13360 if (!SWIG_IsOK(ecode1)) {
13361 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13362 }
13363 arg1 = static_cast< int >(val1);
13364 ecode2 = SWIG_AsVal_int(obj1, &val2);
13365 if (!SWIG_IsOK(ecode2)) {
13366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13367 }
13368 arg2 = static_cast< int >(val2);
13369 {
13370 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13371 }
13372 {
13373 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13374 }
13375 {
13376 PyThreadState* __tstate = wxPyBeginAllowThreads();
13377 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13378 wxPyEndAllowThreads(__tstate);
13379 if (PyErr_Occurred()) SWIG_fail;
13380 }
13381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13382 return resultobj;
13383 fail:
13384 return NULL;
13385 }
13386
13387
13388 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13389 PyObject *resultobj = 0;
13390 wxImage *arg1 = (wxImage *) 0 ;
13391 int arg2 ;
13392 int arg3 ;
13393 bool arg4 = (bool) true ;
13394 void *argp1 = 0 ;
13395 int res1 = 0 ;
13396 int val2 ;
13397 int ecode2 = 0 ;
13398 int val3 ;
13399 int ecode3 = 0 ;
13400 bool val4 ;
13401 int ecode4 = 0 ;
13402 PyObject * obj0 = 0 ;
13403 PyObject * obj1 = 0 ;
13404 PyObject * obj2 = 0 ;
13405 PyObject * obj3 = 0 ;
13406 char * kwnames[] = {
13407 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13408 };
13409
13410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13412 if (!SWIG_IsOK(res1)) {
13413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13414 }
13415 arg1 = reinterpret_cast< wxImage * >(argp1);
13416 ecode2 = SWIG_AsVal_int(obj1, &val2);
13417 if (!SWIG_IsOK(ecode2)) {
13418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13419 }
13420 arg2 = static_cast< int >(val2);
13421 ecode3 = SWIG_AsVal_int(obj2, &val3);
13422 if (!SWIG_IsOK(ecode3)) {
13423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13424 }
13425 arg3 = static_cast< int >(val3);
13426 if (obj3) {
13427 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13428 if (!SWIG_IsOK(ecode4)) {
13429 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13430 }
13431 arg4 = static_cast< bool >(val4);
13432 }
13433 {
13434 PyThreadState* __tstate = wxPyBeginAllowThreads();
13435 (arg1)->Create(arg2,arg3,arg4);
13436 wxPyEndAllowThreads(__tstate);
13437 if (PyErr_Occurred()) SWIG_fail;
13438 }
13439 resultobj = SWIG_Py_Void();
13440 return resultobj;
13441 fail:
13442 return NULL;
13443 }
13444
13445
13446 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13447 PyObject *resultobj = 0;
13448 wxImage *arg1 = (wxImage *) 0 ;
13449 void *argp1 = 0 ;
13450 int res1 = 0 ;
13451 PyObject *swig_obj[1] ;
13452
13453 if (!args) SWIG_fail;
13454 swig_obj[0] = args;
13455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13456 if (!SWIG_IsOK(res1)) {
13457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13458 }
13459 arg1 = reinterpret_cast< wxImage * >(argp1);
13460 {
13461 PyThreadState* __tstate = wxPyBeginAllowThreads();
13462 (arg1)->Destroy();
13463 wxPyEndAllowThreads(__tstate);
13464 if (PyErr_Occurred()) SWIG_fail;
13465 }
13466 resultobj = SWIG_Py_Void();
13467 return resultobj;
13468 fail:
13469 return NULL;
13470 }
13471
13472
13473 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13474 PyObject *resultobj = 0;
13475 wxImage *arg1 = (wxImage *) 0 ;
13476 int arg2 ;
13477 int arg3 ;
13478 SwigValueWrapper<wxImage > result;
13479 void *argp1 = 0 ;
13480 int res1 = 0 ;
13481 int val2 ;
13482 int ecode2 = 0 ;
13483 int val3 ;
13484 int ecode3 = 0 ;
13485 PyObject * obj0 = 0 ;
13486 PyObject * obj1 = 0 ;
13487 PyObject * obj2 = 0 ;
13488 char * kwnames[] = {
13489 (char *) "self",(char *) "width",(char *) "height", NULL
13490 };
13491
13492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13494 if (!SWIG_IsOK(res1)) {
13495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13496 }
13497 arg1 = reinterpret_cast< wxImage * >(argp1);
13498 ecode2 = SWIG_AsVal_int(obj1, &val2);
13499 if (!SWIG_IsOK(ecode2)) {
13500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13501 }
13502 arg2 = static_cast< int >(val2);
13503 ecode3 = SWIG_AsVal_int(obj2, &val3);
13504 if (!SWIG_IsOK(ecode3)) {
13505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13506 }
13507 arg3 = static_cast< int >(val3);
13508 {
13509 PyThreadState* __tstate = wxPyBeginAllowThreads();
13510 result = (arg1)->Scale(arg2,arg3);
13511 wxPyEndAllowThreads(__tstate);
13512 if (PyErr_Occurred()) SWIG_fail;
13513 }
13514 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13515 return resultobj;
13516 fail:
13517 return NULL;
13518 }
13519
13520
13521 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13522 PyObject *resultobj = 0;
13523 wxImage *arg1 = (wxImage *) 0 ;
13524 int arg2 ;
13525 int arg3 ;
13526 SwigValueWrapper<wxImage > result;
13527 void *argp1 = 0 ;
13528 int res1 = 0 ;
13529 int val2 ;
13530 int ecode2 = 0 ;
13531 int val3 ;
13532 int ecode3 = 0 ;
13533 PyObject * obj0 = 0 ;
13534 PyObject * obj1 = 0 ;
13535 PyObject * obj2 = 0 ;
13536 char * kwnames[] = {
13537 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13538 };
13539
13540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13542 if (!SWIG_IsOK(res1)) {
13543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13544 }
13545 arg1 = reinterpret_cast< wxImage * >(argp1);
13546 ecode2 = SWIG_AsVal_int(obj1, &val2);
13547 if (!SWIG_IsOK(ecode2)) {
13548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13549 }
13550 arg2 = static_cast< int >(val2);
13551 ecode3 = SWIG_AsVal_int(obj2, &val3);
13552 if (!SWIG_IsOK(ecode3)) {
13553 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13554 }
13555 arg3 = static_cast< int >(val3);
13556 {
13557 PyThreadState* __tstate = wxPyBeginAllowThreads();
13558 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13559 wxPyEndAllowThreads(__tstate);
13560 if (PyErr_Occurred()) SWIG_fail;
13561 }
13562 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13563 return resultobj;
13564 fail:
13565 return NULL;
13566 }
13567
13568
13569 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13570 PyObject *resultobj = 0;
13571 wxImage *arg1 = (wxImage *) 0 ;
13572 int arg2 ;
13573 int arg3 ;
13574 wxImage *result = 0 ;
13575 void *argp1 = 0 ;
13576 int res1 = 0 ;
13577 int val2 ;
13578 int ecode2 = 0 ;
13579 int val3 ;
13580 int ecode3 = 0 ;
13581 PyObject * obj0 = 0 ;
13582 PyObject * obj1 = 0 ;
13583 PyObject * obj2 = 0 ;
13584 char * kwnames[] = {
13585 (char *) "self",(char *) "width",(char *) "height", NULL
13586 };
13587
13588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13590 if (!SWIG_IsOK(res1)) {
13591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13592 }
13593 arg1 = reinterpret_cast< wxImage * >(argp1);
13594 ecode2 = SWIG_AsVal_int(obj1, &val2);
13595 if (!SWIG_IsOK(ecode2)) {
13596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13597 }
13598 arg2 = static_cast< int >(val2);
13599 ecode3 = SWIG_AsVal_int(obj2, &val3);
13600 if (!SWIG_IsOK(ecode3)) {
13601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13602 }
13603 arg3 = static_cast< int >(val3);
13604 {
13605 PyThreadState* __tstate = wxPyBeginAllowThreads();
13606 {
13607 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13608 result = (wxImage *) &_result_ref;
13609 }
13610 wxPyEndAllowThreads(__tstate);
13611 if (PyErr_Occurred()) SWIG_fail;
13612 }
13613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13614 return resultobj;
13615 fail:
13616 return NULL;
13617 }
13618
13619
13620 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13621 PyObject *resultobj = 0;
13622 wxImage *arg1 = (wxImage *) 0 ;
13623 wxSize *arg2 = 0 ;
13624 wxPoint *arg3 = 0 ;
13625 int arg4 = (int) -1 ;
13626 int arg5 = (int) -1 ;
13627 int arg6 = (int) -1 ;
13628 wxImage *result = 0 ;
13629 void *argp1 = 0 ;
13630 int res1 = 0 ;
13631 wxSize temp2 ;
13632 wxPoint temp3 ;
13633 int val4 ;
13634 int ecode4 = 0 ;
13635 int val5 ;
13636 int ecode5 = 0 ;
13637 int val6 ;
13638 int ecode6 = 0 ;
13639 PyObject * obj0 = 0 ;
13640 PyObject * obj1 = 0 ;
13641 PyObject * obj2 = 0 ;
13642 PyObject * obj3 = 0 ;
13643 PyObject * obj4 = 0 ;
13644 PyObject * obj5 = 0 ;
13645 char * kwnames[] = {
13646 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13647 };
13648
13649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13651 if (!SWIG_IsOK(res1)) {
13652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13653 }
13654 arg1 = reinterpret_cast< wxImage * >(argp1);
13655 {
13656 arg2 = &temp2;
13657 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13658 }
13659 {
13660 arg3 = &temp3;
13661 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13662 }
13663 if (obj3) {
13664 ecode4 = SWIG_AsVal_int(obj3, &val4);
13665 if (!SWIG_IsOK(ecode4)) {
13666 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13667 }
13668 arg4 = static_cast< int >(val4);
13669 }
13670 if (obj4) {
13671 ecode5 = SWIG_AsVal_int(obj4, &val5);
13672 if (!SWIG_IsOK(ecode5)) {
13673 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13674 }
13675 arg5 = static_cast< int >(val5);
13676 }
13677 if (obj5) {
13678 ecode6 = SWIG_AsVal_int(obj5, &val6);
13679 if (!SWIG_IsOK(ecode6)) {
13680 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13681 }
13682 arg6 = static_cast< int >(val6);
13683 }
13684 {
13685 PyThreadState* __tstate = wxPyBeginAllowThreads();
13686 {
13687 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13688 result = (wxImage *) &_result_ref;
13689 }
13690 wxPyEndAllowThreads(__tstate);
13691 if (PyErr_Occurred()) SWIG_fail;
13692 }
13693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13694 return resultobj;
13695 fail:
13696 return NULL;
13697 }
13698
13699
13700 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13701 PyObject *resultobj = 0;
13702 wxImage *arg1 = (wxImage *) 0 ;
13703 int arg2 ;
13704 int arg3 ;
13705 byte arg4 ;
13706 byte arg5 ;
13707 byte arg6 ;
13708 void *argp1 = 0 ;
13709 int res1 = 0 ;
13710 int val2 ;
13711 int ecode2 = 0 ;
13712 int val3 ;
13713 int ecode3 = 0 ;
13714 unsigned char val4 ;
13715 int ecode4 = 0 ;
13716 unsigned char val5 ;
13717 int ecode5 = 0 ;
13718 unsigned char val6 ;
13719 int ecode6 = 0 ;
13720 PyObject * obj0 = 0 ;
13721 PyObject * obj1 = 0 ;
13722 PyObject * obj2 = 0 ;
13723 PyObject * obj3 = 0 ;
13724 PyObject * obj4 = 0 ;
13725 PyObject * obj5 = 0 ;
13726 char * kwnames[] = {
13727 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13728 };
13729
13730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13732 if (!SWIG_IsOK(res1)) {
13733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13734 }
13735 arg1 = reinterpret_cast< wxImage * >(argp1);
13736 ecode2 = SWIG_AsVal_int(obj1, &val2);
13737 if (!SWIG_IsOK(ecode2)) {
13738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13739 }
13740 arg2 = static_cast< int >(val2);
13741 ecode3 = SWIG_AsVal_int(obj2, &val3);
13742 if (!SWIG_IsOK(ecode3)) {
13743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13744 }
13745 arg3 = static_cast< int >(val3);
13746 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13747 if (!SWIG_IsOK(ecode4)) {
13748 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13749 }
13750 arg4 = static_cast< byte >(val4);
13751 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13752 if (!SWIG_IsOK(ecode5)) {
13753 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13754 }
13755 arg5 = static_cast< byte >(val5);
13756 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13757 if (!SWIG_IsOK(ecode6)) {
13758 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13759 }
13760 arg6 = static_cast< byte >(val6);
13761 {
13762 PyThreadState* __tstate = wxPyBeginAllowThreads();
13763 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
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_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13775 PyObject *resultobj = 0;
13776 wxImage *arg1 = (wxImage *) 0 ;
13777 wxRect *arg2 = 0 ;
13778 byte arg3 ;
13779 byte arg4 ;
13780 byte arg5 ;
13781 void *argp1 = 0 ;
13782 int res1 = 0 ;
13783 wxRect temp2 ;
13784 unsigned char val3 ;
13785 int ecode3 = 0 ;
13786 unsigned char val4 ;
13787 int ecode4 = 0 ;
13788 unsigned char val5 ;
13789 int ecode5 = 0 ;
13790 PyObject * obj0 = 0 ;
13791 PyObject * obj1 = 0 ;
13792 PyObject * obj2 = 0 ;
13793 PyObject * obj3 = 0 ;
13794 PyObject * obj4 = 0 ;
13795 char * kwnames[] = {
13796 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13797 };
13798
13799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13801 if (!SWIG_IsOK(res1)) {
13802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13803 }
13804 arg1 = reinterpret_cast< wxImage * >(argp1);
13805 {
13806 arg2 = &temp2;
13807 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13808 }
13809 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13810 if (!SWIG_IsOK(ecode3)) {
13811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13812 }
13813 arg3 = static_cast< byte >(val3);
13814 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13815 if (!SWIG_IsOK(ecode4)) {
13816 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13817 }
13818 arg4 = static_cast< byte >(val4);
13819 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13820 if (!SWIG_IsOK(ecode5)) {
13821 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13822 }
13823 arg5 = static_cast< byte >(val5);
13824 {
13825 PyThreadState* __tstate = wxPyBeginAllowThreads();
13826 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13827 wxPyEndAllowThreads(__tstate);
13828 if (PyErr_Occurred()) SWIG_fail;
13829 }
13830 resultobj = SWIG_Py_Void();
13831 return resultobj;
13832 fail:
13833 return NULL;
13834 }
13835
13836
13837 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13838 PyObject *resultobj = 0;
13839 wxImage *arg1 = (wxImage *) 0 ;
13840 int arg2 ;
13841 int arg3 ;
13842 byte result;
13843 void *argp1 = 0 ;
13844 int res1 = 0 ;
13845 int val2 ;
13846 int ecode2 = 0 ;
13847 int val3 ;
13848 int ecode3 = 0 ;
13849 PyObject * obj0 = 0 ;
13850 PyObject * obj1 = 0 ;
13851 PyObject * obj2 = 0 ;
13852 char * kwnames[] = {
13853 (char *) "self",(char *) "x",(char *) "y", NULL
13854 };
13855
13856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13858 if (!SWIG_IsOK(res1)) {
13859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13860 }
13861 arg1 = reinterpret_cast< wxImage * >(argp1);
13862 ecode2 = SWIG_AsVal_int(obj1, &val2);
13863 if (!SWIG_IsOK(ecode2)) {
13864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13865 }
13866 arg2 = static_cast< int >(val2);
13867 ecode3 = SWIG_AsVal_int(obj2, &val3);
13868 if (!SWIG_IsOK(ecode3)) {
13869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13870 }
13871 arg3 = static_cast< int >(val3);
13872 {
13873 PyThreadState* __tstate = wxPyBeginAllowThreads();
13874 result = (byte)(arg1)->GetRed(arg2,arg3);
13875 wxPyEndAllowThreads(__tstate);
13876 if (PyErr_Occurred()) SWIG_fail;
13877 }
13878 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13879 return resultobj;
13880 fail:
13881 return NULL;
13882 }
13883
13884
13885 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13886 PyObject *resultobj = 0;
13887 wxImage *arg1 = (wxImage *) 0 ;
13888 int arg2 ;
13889 int arg3 ;
13890 byte result;
13891 void *argp1 = 0 ;
13892 int res1 = 0 ;
13893 int val2 ;
13894 int ecode2 = 0 ;
13895 int val3 ;
13896 int ecode3 = 0 ;
13897 PyObject * obj0 = 0 ;
13898 PyObject * obj1 = 0 ;
13899 PyObject * obj2 = 0 ;
13900 char * kwnames[] = {
13901 (char *) "self",(char *) "x",(char *) "y", NULL
13902 };
13903
13904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13906 if (!SWIG_IsOK(res1)) {
13907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13908 }
13909 arg1 = reinterpret_cast< wxImage * >(argp1);
13910 ecode2 = SWIG_AsVal_int(obj1, &val2);
13911 if (!SWIG_IsOK(ecode2)) {
13912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13913 }
13914 arg2 = static_cast< int >(val2);
13915 ecode3 = SWIG_AsVal_int(obj2, &val3);
13916 if (!SWIG_IsOK(ecode3)) {
13917 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13918 }
13919 arg3 = static_cast< int >(val3);
13920 {
13921 PyThreadState* __tstate = wxPyBeginAllowThreads();
13922 result = (byte)(arg1)->GetGreen(arg2,arg3);
13923 wxPyEndAllowThreads(__tstate);
13924 if (PyErr_Occurred()) SWIG_fail;
13925 }
13926 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13927 return resultobj;
13928 fail:
13929 return NULL;
13930 }
13931
13932
13933 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13934 PyObject *resultobj = 0;
13935 wxImage *arg1 = (wxImage *) 0 ;
13936 int arg2 ;
13937 int arg3 ;
13938 byte result;
13939 void *argp1 = 0 ;
13940 int res1 = 0 ;
13941 int val2 ;
13942 int ecode2 = 0 ;
13943 int val3 ;
13944 int ecode3 = 0 ;
13945 PyObject * obj0 = 0 ;
13946 PyObject * obj1 = 0 ;
13947 PyObject * obj2 = 0 ;
13948 char * kwnames[] = {
13949 (char *) "self",(char *) "x",(char *) "y", NULL
13950 };
13951
13952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13954 if (!SWIG_IsOK(res1)) {
13955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13956 }
13957 arg1 = reinterpret_cast< wxImage * >(argp1);
13958 ecode2 = SWIG_AsVal_int(obj1, &val2);
13959 if (!SWIG_IsOK(ecode2)) {
13960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13961 }
13962 arg2 = static_cast< int >(val2);
13963 ecode3 = SWIG_AsVal_int(obj2, &val3);
13964 if (!SWIG_IsOK(ecode3)) {
13965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13966 }
13967 arg3 = static_cast< int >(val3);
13968 {
13969 PyThreadState* __tstate = wxPyBeginAllowThreads();
13970 result = (byte)(arg1)->GetBlue(arg2,arg3);
13971 wxPyEndAllowThreads(__tstate);
13972 if (PyErr_Occurred()) SWIG_fail;
13973 }
13974 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13975 return resultobj;
13976 fail:
13977 return NULL;
13978 }
13979
13980
13981 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13982 PyObject *resultobj = 0;
13983 wxImage *arg1 = (wxImage *) 0 ;
13984 int arg2 ;
13985 int arg3 ;
13986 byte arg4 ;
13987 void *argp1 = 0 ;
13988 int res1 = 0 ;
13989 int val2 ;
13990 int ecode2 = 0 ;
13991 int val3 ;
13992 int ecode3 = 0 ;
13993 unsigned char val4 ;
13994 int ecode4 = 0 ;
13995 PyObject * obj0 = 0 ;
13996 PyObject * obj1 = 0 ;
13997 PyObject * obj2 = 0 ;
13998 PyObject * obj3 = 0 ;
13999 char * kwnames[] = {
14000 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14001 };
14002
14003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14005 if (!SWIG_IsOK(res1)) {
14006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14007 }
14008 arg1 = reinterpret_cast< wxImage * >(argp1);
14009 ecode2 = SWIG_AsVal_int(obj1, &val2);
14010 if (!SWIG_IsOK(ecode2)) {
14011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14012 }
14013 arg2 = static_cast< int >(val2);
14014 ecode3 = SWIG_AsVal_int(obj2, &val3);
14015 if (!SWIG_IsOK(ecode3)) {
14016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14017 }
14018 arg3 = static_cast< int >(val3);
14019 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14020 if (!SWIG_IsOK(ecode4)) {
14021 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14022 }
14023 arg4 = static_cast< byte >(val4);
14024 {
14025 PyThreadState* __tstate = wxPyBeginAllowThreads();
14026 (arg1)->SetAlpha(arg2,arg3,arg4);
14027 wxPyEndAllowThreads(__tstate);
14028 if (PyErr_Occurred()) SWIG_fail;
14029 }
14030 resultobj = SWIG_Py_Void();
14031 return resultobj;
14032 fail:
14033 return NULL;
14034 }
14035
14036
14037 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14038 PyObject *resultobj = 0;
14039 wxImage *arg1 = (wxImage *) 0 ;
14040 int arg2 ;
14041 int arg3 ;
14042 byte result;
14043 void *argp1 = 0 ;
14044 int res1 = 0 ;
14045 int val2 ;
14046 int ecode2 = 0 ;
14047 int val3 ;
14048 int ecode3 = 0 ;
14049 PyObject * obj0 = 0 ;
14050 PyObject * obj1 = 0 ;
14051 PyObject * obj2 = 0 ;
14052 char * kwnames[] = {
14053 (char *) "self",(char *) "x",(char *) "y", NULL
14054 };
14055
14056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14058 if (!SWIG_IsOK(res1)) {
14059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14060 }
14061 arg1 = reinterpret_cast< wxImage * >(argp1);
14062 ecode2 = SWIG_AsVal_int(obj1, &val2);
14063 if (!SWIG_IsOK(ecode2)) {
14064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14065 }
14066 arg2 = static_cast< int >(val2);
14067 ecode3 = SWIG_AsVal_int(obj2, &val3);
14068 if (!SWIG_IsOK(ecode3)) {
14069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14070 }
14071 arg3 = static_cast< int >(val3);
14072 {
14073 PyThreadState* __tstate = wxPyBeginAllowThreads();
14074 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14075 wxPyEndAllowThreads(__tstate);
14076 if (PyErr_Occurred()) SWIG_fail;
14077 }
14078 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14079 return resultobj;
14080 fail:
14081 return NULL;
14082 }
14083
14084
14085 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14086 PyObject *resultobj = 0;
14087 wxImage *arg1 = (wxImage *) 0 ;
14088 bool result;
14089 void *argp1 = 0 ;
14090 int res1 = 0 ;
14091 PyObject *swig_obj[1] ;
14092
14093 if (!args) SWIG_fail;
14094 swig_obj[0] = args;
14095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14096 if (!SWIG_IsOK(res1)) {
14097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14098 }
14099 arg1 = reinterpret_cast< wxImage * >(argp1);
14100 {
14101 PyThreadState* __tstate = wxPyBeginAllowThreads();
14102 result = (bool)(arg1)->HasAlpha();
14103 wxPyEndAllowThreads(__tstate);
14104 if (PyErr_Occurred()) SWIG_fail;
14105 }
14106 {
14107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14108 }
14109 return resultobj;
14110 fail:
14111 return NULL;
14112 }
14113
14114
14115 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14116 PyObject *resultobj = 0;
14117 wxImage *arg1 = (wxImage *) 0 ;
14118 void *argp1 = 0 ;
14119 int res1 = 0 ;
14120 PyObject *swig_obj[1] ;
14121
14122 if (!args) SWIG_fail;
14123 swig_obj[0] = args;
14124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14125 if (!SWIG_IsOK(res1)) {
14126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14127 }
14128 arg1 = reinterpret_cast< wxImage * >(argp1);
14129 {
14130 PyThreadState* __tstate = wxPyBeginAllowThreads();
14131 (arg1)->InitAlpha();
14132 wxPyEndAllowThreads(__tstate);
14133 if (PyErr_Occurred()) SWIG_fail;
14134 }
14135 resultobj = SWIG_Py_Void();
14136 return resultobj;
14137 fail:
14138 return NULL;
14139 }
14140
14141
14142 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14143 PyObject *resultobj = 0;
14144 wxImage *arg1 = (wxImage *) 0 ;
14145 int arg2 ;
14146 int arg3 ;
14147 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14148 bool result;
14149 void *argp1 = 0 ;
14150 int res1 = 0 ;
14151 int val2 ;
14152 int ecode2 = 0 ;
14153 int val3 ;
14154 int ecode3 = 0 ;
14155 unsigned char val4 ;
14156 int ecode4 = 0 ;
14157 PyObject * obj0 = 0 ;
14158 PyObject * obj1 = 0 ;
14159 PyObject * obj2 = 0 ;
14160 PyObject * obj3 = 0 ;
14161 char * kwnames[] = {
14162 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14163 };
14164
14165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14167 if (!SWIG_IsOK(res1)) {
14168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14169 }
14170 arg1 = reinterpret_cast< wxImage * >(argp1);
14171 ecode2 = SWIG_AsVal_int(obj1, &val2);
14172 if (!SWIG_IsOK(ecode2)) {
14173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14174 }
14175 arg2 = static_cast< int >(val2);
14176 ecode3 = SWIG_AsVal_int(obj2, &val3);
14177 if (!SWIG_IsOK(ecode3)) {
14178 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14179 }
14180 arg3 = static_cast< int >(val3);
14181 if (obj3) {
14182 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14183 if (!SWIG_IsOK(ecode4)) {
14184 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14185 }
14186 arg4 = static_cast< byte >(val4);
14187 }
14188 {
14189 PyThreadState* __tstate = wxPyBeginAllowThreads();
14190 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14191 wxPyEndAllowThreads(__tstate);
14192 if (PyErr_Occurred()) SWIG_fail;
14193 }
14194 {
14195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14196 }
14197 return resultobj;
14198 fail:
14199 return NULL;
14200 }
14201
14202
14203 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14204 PyObject *resultobj = 0;
14205 wxImage *arg1 = (wxImage *) 0 ;
14206 byte *arg2 = (byte *) 0 ;
14207 byte *arg3 = (byte *) 0 ;
14208 byte *arg4 = (byte *) 0 ;
14209 byte arg5 = (byte) 0 ;
14210 byte arg6 = (byte) 0 ;
14211 byte arg7 = (byte) 0 ;
14212 bool result;
14213 void *argp1 = 0 ;
14214 int res1 = 0 ;
14215 byte temp2 ;
14216 int res2 = SWIG_TMPOBJ ;
14217 byte temp3 ;
14218 int res3 = SWIG_TMPOBJ ;
14219 byte temp4 ;
14220 int res4 = SWIG_TMPOBJ ;
14221 unsigned char val5 ;
14222 int ecode5 = 0 ;
14223 unsigned char val6 ;
14224 int ecode6 = 0 ;
14225 unsigned char val7 ;
14226 int ecode7 = 0 ;
14227 PyObject * obj0 = 0 ;
14228 PyObject * obj1 = 0 ;
14229 PyObject * obj2 = 0 ;
14230 PyObject * obj3 = 0 ;
14231 char * kwnames[] = {
14232 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14233 };
14234
14235 arg2 = &temp2;
14236 arg3 = &temp3;
14237 arg4 = &temp4;
14238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14240 if (!SWIG_IsOK(res1)) {
14241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14242 }
14243 arg1 = reinterpret_cast< wxImage * >(argp1);
14244 if (obj1) {
14245 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14246 if (!SWIG_IsOK(ecode5)) {
14247 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14248 }
14249 arg5 = static_cast< byte >(val5);
14250 }
14251 if (obj2) {
14252 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14253 if (!SWIG_IsOK(ecode6)) {
14254 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14255 }
14256 arg6 = static_cast< byte >(val6);
14257 }
14258 if (obj3) {
14259 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14260 if (!SWIG_IsOK(ecode7)) {
14261 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14262 }
14263 arg7 = static_cast< byte >(val7);
14264 }
14265 {
14266 PyThreadState* __tstate = wxPyBeginAllowThreads();
14267 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14268 wxPyEndAllowThreads(__tstate);
14269 if (PyErr_Occurred()) SWIG_fail;
14270 }
14271 {
14272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14273 }
14274 if (SWIG_IsTmpObj(res2)) {
14275 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14276 } else {
14277 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14278 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14279 }
14280 if (SWIG_IsTmpObj(res3)) {
14281 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14282 } else {
14283 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14284 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14285 }
14286 if (SWIG_IsTmpObj(res4)) {
14287 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14288 } else {
14289 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14290 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14291 }
14292 return resultobj;
14293 fail:
14294 return NULL;
14295 }
14296
14297
14298 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14299 PyObject *resultobj = 0;
14300 wxImage *arg1 = (wxImage *) 0 ;
14301 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14302 bool result;
14303 void *argp1 = 0 ;
14304 int res1 = 0 ;
14305 unsigned char val2 ;
14306 int ecode2 = 0 ;
14307 PyObject * obj0 = 0 ;
14308 PyObject * obj1 = 0 ;
14309 char * kwnames[] = {
14310 (char *) "self",(char *) "threshold", NULL
14311 };
14312
14313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14315 if (!SWIG_IsOK(res1)) {
14316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14317 }
14318 arg1 = reinterpret_cast< wxImage * >(argp1);
14319 if (obj1) {
14320 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14321 if (!SWIG_IsOK(ecode2)) {
14322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14323 }
14324 arg2 = static_cast< byte >(val2);
14325 }
14326 {
14327 PyThreadState* __tstate = wxPyBeginAllowThreads();
14328 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14329 wxPyEndAllowThreads(__tstate);
14330 if (PyErr_Occurred()) SWIG_fail;
14331 }
14332 {
14333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14334 }
14335 return resultobj;
14336 fail:
14337 return NULL;
14338 }
14339
14340
14341 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14342 PyObject *resultobj = 0;
14343 wxImage *arg1 = (wxImage *) 0 ;
14344 byte arg2 ;
14345 byte arg3 ;
14346 byte arg4 ;
14347 bool result;
14348 void *argp1 = 0 ;
14349 int res1 = 0 ;
14350 unsigned char val2 ;
14351 int ecode2 = 0 ;
14352 unsigned char val3 ;
14353 int ecode3 = 0 ;
14354 unsigned char val4 ;
14355 int ecode4 = 0 ;
14356 PyObject * obj0 = 0 ;
14357 PyObject * obj1 = 0 ;
14358 PyObject * obj2 = 0 ;
14359 PyObject * obj3 = 0 ;
14360 char * kwnames[] = {
14361 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14362 };
14363
14364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14368 }
14369 arg1 = reinterpret_cast< wxImage * >(argp1);
14370 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14371 if (!SWIG_IsOK(ecode2)) {
14372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14373 }
14374 arg2 = static_cast< byte >(val2);
14375 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14376 if (!SWIG_IsOK(ecode3)) {
14377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14378 }
14379 arg3 = static_cast< byte >(val3);
14380 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14381 if (!SWIG_IsOK(ecode4)) {
14382 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14383 }
14384 arg4 = static_cast< byte >(val4);
14385 {
14386 PyThreadState* __tstate = wxPyBeginAllowThreads();
14387 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14388 wxPyEndAllowThreads(__tstate);
14389 if (PyErr_Occurred()) SWIG_fail;
14390 }
14391 {
14392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14393 }
14394 return resultobj;
14395 fail:
14396 return NULL;
14397 }
14398
14399
14400 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14401 PyObject *resultobj = 0;
14402 wxImage *arg1 = (wxImage *) 0 ;
14403 wxImage *arg2 = 0 ;
14404 byte arg3 ;
14405 byte arg4 ;
14406 byte arg5 ;
14407 bool result;
14408 void *argp1 = 0 ;
14409 int res1 = 0 ;
14410 void *argp2 = 0 ;
14411 int res2 = 0 ;
14412 unsigned char val3 ;
14413 int ecode3 = 0 ;
14414 unsigned char val4 ;
14415 int ecode4 = 0 ;
14416 unsigned char val5 ;
14417 int ecode5 = 0 ;
14418 PyObject * obj0 = 0 ;
14419 PyObject * obj1 = 0 ;
14420 PyObject * obj2 = 0 ;
14421 PyObject * obj3 = 0 ;
14422 PyObject * obj4 = 0 ;
14423 char * kwnames[] = {
14424 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14425 };
14426
14427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14429 if (!SWIG_IsOK(res1)) {
14430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14431 }
14432 arg1 = reinterpret_cast< wxImage * >(argp1);
14433 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14434 if (!SWIG_IsOK(res2)) {
14435 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14436 }
14437 if (!argp2) {
14438 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14439 }
14440 arg2 = reinterpret_cast< wxImage * >(argp2);
14441 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14442 if (!SWIG_IsOK(ecode3)) {
14443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14444 }
14445 arg3 = static_cast< byte >(val3);
14446 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14447 if (!SWIG_IsOK(ecode4)) {
14448 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14449 }
14450 arg4 = static_cast< byte >(val4);
14451 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14452 if (!SWIG_IsOK(ecode5)) {
14453 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14454 }
14455 arg5 = static_cast< byte >(val5);
14456 {
14457 PyThreadState* __tstate = wxPyBeginAllowThreads();
14458 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14459 wxPyEndAllowThreads(__tstate);
14460 if (PyErr_Occurred()) SWIG_fail;
14461 }
14462 {
14463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14464 }
14465 return resultobj;
14466 fail:
14467 return NULL;
14468 }
14469
14470
14471 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14472 PyObject *resultobj = 0;
14473 wxString *arg1 = 0 ;
14474 bool result;
14475 bool temp1 = false ;
14476 PyObject * obj0 = 0 ;
14477 char * kwnames[] = {
14478 (char *) "filename", NULL
14479 };
14480
14481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14482 {
14483 arg1 = wxString_in_helper(obj0);
14484 if (arg1 == NULL) SWIG_fail;
14485 temp1 = true;
14486 }
14487 {
14488 PyThreadState* __tstate = wxPyBeginAllowThreads();
14489 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14490 wxPyEndAllowThreads(__tstate);
14491 if (PyErr_Occurred()) SWIG_fail;
14492 }
14493 {
14494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14495 }
14496 {
14497 if (temp1)
14498 delete arg1;
14499 }
14500 return resultobj;
14501 fail:
14502 {
14503 if (temp1)
14504 delete arg1;
14505 }
14506 return NULL;
14507 }
14508
14509
14510 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14511 PyObject *resultobj = 0;
14512 wxString *arg1 = 0 ;
14513 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14514 int result;
14515 bool temp1 = false ;
14516 long val2 ;
14517 int ecode2 = 0 ;
14518 PyObject * obj0 = 0 ;
14519 PyObject * obj1 = 0 ;
14520 char * kwnames[] = {
14521 (char *) "filename",(char *) "type", NULL
14522 };
14523
14524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14525 {
14526 arg1 = wxString_in_helper(obj0);
14527 if (arg1 == NULL) SWIG_fail;
14528 temp1 = true;
14529 }
14530 if (obj1) {
14531 ecode2 = SWIG_AsVal_long(obj1, &val2);
14532 if (!SWIG_IsOK(ecode2)) {
14533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14534 }
14535 arg2 = static_cast< long >(val2);
14536 }
14537 {
14538 PyThreadState* __tstate = wxPyBeginAllowThreads();
14539 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14540 wxPyEndAllowThreads(__tstate);
14541 if (PyErr_Occurred()) SWIG_fail;
14542 }
14543 resultobj = SWIG_From_int(static_cast< int >(result));
14544 {
14545 if (temp1)
14546 delete arg1;
14547 }
14548 return resultobj;
14549 fail:
14550 {
14551 if (temp1)
14552 delete arg1;
14553 }
14554 return NULL;
14555 }
14556
14557
14558 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14559 PyObject *resultobj = 0;
14560 wxImage *arg1 = (wxImage *) 0 ;
14561 wxString *arg2 = 0 ;
14562 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14563 int arg4 = (int) -1 ;
14564 bool result;
14565 void *argp1 = 0 ;
14566 int res1 = 0 ;
14567 bool temp2 = false ;
14568 long val3 ;
14569 int ecode3 = 0 ;
14570 int val4 ;
14571 int ecode4 = 0 ;
14572 PyObject * obj0 = 0 ;
14573 PyObject * obj1 = 0 ;
14574 PyObject * obj2 = 0 ;
14575 PyObject * obj3 = 0 ;
14576 char * kwnames[] = {
14577 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14578 };
14579
14580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14582 if (!SWIG_IsOK(res1)) {
14583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14584 }
14585 arg1 = reinterpret_cast< wxImage * >(argp1);
14586 {
14587 arg2 = wxString_in_helper(obj1);
14588 if (arg2 == NULL) SWIG_fail;
14589 temp2 = true;
14590 }
14591 if (obj2) {
14592 ecode3 = SWIG_AsVal_long(obj2, &val3);
14593 if (!SWIG_IsOK(ecode3)) {
14594 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14595 }
14596 arg3 = static_cast< long >(val3);
14597 }
14598 if (obj3) {
14599 ecode4 = SWIG_AsVal_int(obj3, &val4);
14600 if (!SWIG_IsOK(ecode4)) {
14601 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14602 }
14603 arg4 = static_cast< int >(val4);
14604 }
14605 {
14606 PyThreadState* __tstate = wxPyBeginAllowThreads();
14607 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14608 wxPyEndAllowThreads(__tstate);
14609 if (PyErr_Occurred()) SWIG_fail;
14610 }
14611 {
14612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14613 }
14614 {
14615 if (temp2)
14616 delete arg2;
14617 }
14618 return resultobj;
14619 fail:
14620 {
14621 if (temp2)
14622 delete arg2;
14623 }
14624 return NULL;
14625 }
14626
14627
14628 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14629 PyObject *resultobj = 0;
14630 wxImage *arg1 = (wxImage *) 0 ;
14631 wxString *arg2 = 0 ;
14632 wxString *arg3 = 0 ;
14633 int arg4 = (int) -1 ;
14634 bool result;
14635 void *argp1 = 0 ;
14636 int res1 = 0 ;
14637 bool temp2 = false ;
14638 bool temp3 = false ;
14639 int val4 ;
14640 int ecode4 = 0 ;
14641 PyObject * obj0 = 0 ;
14642 PyObject * obj1 = 0 ;
14643 PyObject * obj2 = 0 ;
14644 PyObject * obj3 = 0 ;
14645 char * kwnames[] = {
14646 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14647 };
14648
14649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14651 if (!SWIG_IsOK(res1)) {
14652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14653 }
14654 arg1 = reinterpret_cast< wxImage * >(argp1);
14655 {
14656 arg2 = wxString_in_helper(obj1);
14657 if (arg2 == NULL) SWIG_fail;
14658 temp2 = true;
14659 }
14660 {
14661 arg3 = wxString_in_helper(obj2);
14662 if (arg3 == NULL) SWIG_fail;
14663 temp3 = true;
14664 }
14665 if (obj3) {
14666 ecode4 = SWIG_AsVal_int(obj3, &val4);
14667 if (!SWIG_IsOK(ecode4)) {
14668 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14669 }
14670 arg4 = static_cast< int >(val4);
14671 }
14672 {
14673 PyThreadState* __tstate = wxPyBeginAllowThreads();
14674 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14675 wxPyEndAllowThreads(__tstate);
14676 if (PyErr_Occurred()) SWIG_fail;
14677 }
14678 {
14679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14680 }
14681 {
14682 if (temp2)
14683 delete arg2;
14684 }
14685 {
14686 if (temp3)
14687 delete arg3;
14688 }
14689 return resultobj;
14690 fail:
14691 {
14692 if (temp2)
14693 delete arg2;
14694 }
14695 {
14696 if (temp3)
14697 delete arg3;
14698 }
14699 return NULL;
14700 }
14701
14702
14703 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14704 PyObject *resultobj = 0;
14705 wxImage *arg1 = (wxImage *) 0 ;
14706 wxString *arg2 = 0 ;
14707 int arg3 ;
14708 bool result;
14709 void *argp1 = 0 ;
14710 int res1 = 0 ;
14711 bool temp2 = false ;
14712 int val3 ;
14713 int ecode3 = 0 ;
14714 PyObject * obj0 = 0 ;
14715 PyObject * obj1 = 0 ;
14716 PyObject * obj2 = 0 ;
14717 char * kwnames[] = {
14718 (char *) "self",(char *) "name",(char *) "type", NULL
14719 };
14720
14721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14723 if (!SWIG_IsOK(res1)) {
14724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14725 }
14726 arg1 = reinterpret_cast< wxImage * >(argp1);
14727 {
14728 arg2 = wxString_in_helper(obj1);
14729 if (arg2 == NULL) SWIG_fail;
14730 temp2 = true;
14731 }
14732 ecode3 = SWIG_AsVal_int(obj2, &val3);
14733 if (!SWIG_IsOK(ecode3)) {
14734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14735 }
14736 arg3 = static_cast< int >(val3);
14737 {
14738 PyThreadState* __tstate = wxPyBeginAllowThreads();
14739 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14740 wxPyEndAllowThreads(__tstate);
14741 if (PyErr_Occurred()) SWIG_fail;
14742 }
14743 {
14744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14745 }
14746 {
14747 if (temp2)
14748 delete arg2;
14749 }
14750 return resultobj;
14751 fail:
14752 {
14753 if (temp2)
14754 delete arg2;
14755 }
14756 return NULL;
14757 }
14758
14759
14760 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14761 PyObject *resultobj = 0;
14762 wxImage *arg1 = (wxImage *) 0 ;
14763 wxString *arg2 = 0 ;
14764 wxString *arg3 = 0 ;
14765 bool result;
14766 void *argp1 = 0 ;
14767 int res1 = 0 ;
14768 bool temp2 = false ;
14769 bool temp3 = false ;
14770 PyObject * obj0 = 0 ;
14771 PyObject * obj1 = 0 ;
14772 PyObject * obj2 = 0 ;
14773 char * kwnames[] = {
14774 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14775 };
14776
14777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14779 if (!SWIG_IsOK(res1)) {
14780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14781 }
14782 arg1 = reinterpret_cast< wxImage * >(argp1);
14783 {
14784 arg2 = wxString_in_helper(obj1);
14785 if (arg2 == NULL) SWIG_fail;
14786 temp2 = true;
14787 }
14788 {
14789 arg3 = wxString_in_helper(obj2);
14790 if (arg3 == NULL) SWIG_fail;
14791 temp3 = true;
14792 }
14793 {
14794 PyThreadState* __tstate = wxPyBeginAllowThreads();
14795 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14796 wxPyEndAllowThreads(__tstate);
14797 if (PyErr_Occurred()) SWIG_fail;
14798 }
14799 {
14800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14801 }
14802 {
14803 if (temp2)
14804 delete arg2;
14805 }
14806 {
14807 if (temp3)
14808 delete arg3;
14809 }
14810 return resultobj;
14811 fail:
14812 {
14813 if (temp2)
14814 delete arg2;
14815 }
14816 {
14817 if (temp3)
14818 delete arg3;
14819 }
14820 return NULL;
14821 }
14822
14823
14824 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14825 PyObject *resultobj = 0;
14826 wxInputStream *arg1 = 0 ;
14827 bool result;
14828 wxPyInputStream *temp1 ;
14829 bool created1 ;
14830 PyObject * obj0 = 0 ;
14831 char * kwnames[] = {
14832 (char *) "stream", NULL
14833 };
14834
14835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14836 {
14837 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14838 arg1 = temp1->m_wxis;
14839 created1 = false;
14840 } else {
14841 PyErr_Clear(); // clear the failure of the wxPyConvert above
14842 arg1 = wxPyCBInputStream_create(obj0, false);
14843 if (arg1 == NULL) {
14844 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14845 SWIG_fail;
14846 }
14847 created1 = true;
14848 }
14849 }
14850 {
14851 PyThreadState* __tstate = wxPyBeginAllowThreads();
14852 result = (bool)wxImage::CanRead(*arg1);
14853 wxPyEndAllowThreads(__tstate);
14854 if (PyErr_Occurred()) SWIG_fail;
14855 }
14856 {
14857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14858 }
14859 {
14860 if (created1) delete arg1;
14861 }
14862 return resultobj;
14863 fail:
14864 {
14865 if (created1) delete arg1;
14866 }
14867 return NULL;
14868 }
14869
14870
14871 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14872 PyObject *resultobj = 0;
14873 wxImage *arg1 = (wxImage *) 0 ;
14874 wxInputStream *arg2 = 0 ;
14875 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14876 int arg4 = (int) -1 ;
14877 bool result;
14878 void *argp1 = 0 ;
14879 int res1 = 0 ;
14880 wxPyInputStream *temp2 ;
14881 bool created2 ;
14882 long val3 ;
14883 int ecode3 = 0 ;
14884 int val4 ;
14885 int ecode4 = 0 ;
14886 PyObject * obj0 = 0 ;
14887 PyObject * obj1 = 0 ;
14888 PyObject * obj2 = 0 ;
14889 PyObject * obj3 = 0 ;
14890 char * kwnames[] = {
14891 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14892 };
14893
14894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14896 if (!SWIG_IsOK(res1)) {
14897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14898 }
14899 arg1 = reinterpret_cast< wxImage * >(argp1);
14900 {
14901 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14902 arg2 = temp2->m_wxis;
14903 created2 = false;
14904 } else {
14905 PyErr_Clear(); // clear the failure of the wxPyConvert above
14906 arg2 = wxPyCBInputStream_create(obj1, false);
14907 if (arg2 == NULL) {
14908 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14909 SWIG_fail;
14910 }
14911 created2 = true;
14912 }
14913 }
14914 if (obj2) {
14915 ecode3 = SWIG_AsVal_long(obj2, &val3);
14916 if (!SWIG_IsOK(ecode3)) {
14917 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14918 }
14919 arg3 = static_cast< long >(val3);
14920 }
14921 if (obj3) {
14922 ecode4 = SWIG_AsVal_int(obj3, &val4);
14923 if (!SWIG_IsOK(ecode4)) {
14924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14925 }
14926 arg4 = static_cast< int >(val4);
14927 }
14928 {
14929 PyThreadState* __tstate = wxPyBeginAllowThreads();
14930 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14931 wxPyEndAllowThreads(__tstate);
14932 if (PyErr_Occurred()) SWIG_fail;
14933 }
14934 {
14935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14936 }
14937 {
14938 if (created2) delete arg2;
14939 }
14940 return resultobj;
14941 fail:
14942 {
14943 if (created2) delete arg2;
14944 }
14945 return NULL;
14946 }
14947
14948
14949 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14950 PyObject *resultobj = 0;
14951 wxImage *arg1 = (wxImage *) 0 ;
14952 wxInputStream *arg2 = 0 ;
14953 wxString *arg3 = 0 ;
14954 int arg4 = (int) -1 ;
14955 bool result;
14956 void *argp1 = 0 ;
14957 int res1 = 0 ;
14958 wxPyInputStream *temp2 ;
14959 bool created2 ;
14960 bool temp3 = false ;
14961 int val4 ;
14962 int ecode4 = 0 ;
14963 PyObject * obj0 = 0 ;
14964 PyObject * obj1 = 0 ;
14965 PyObject * obj2 = 0 ;
14966 PyObject * obj3 = 0 ;
14967 char * kwnames[] = {
14968 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14969 };
14970
14971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14973 if (!SWIG_IsOK(res1)) {
14974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14975 }
14976 arg1 = reinterpret_cast< wxImage * >(argp1);
14977 {
14978 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14979 arg2 = temp2->m_wxis;
14980 created2 = false;
14981 } else {
14982 PyErr_Clear(); // clear the failure of the wxPyConvert above
14983 arg2 = wxPyCBInputStream_create(obj1, false);
14984 if (arg2 == NULL) {
14985 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14986 SWIG_fail;
14987 }
14988 created2 = true;
14989 }
14990 }
14991 {
14992 arg3 = wxString_in_helper(obj2);
14993 if (arg3 == NULL) SWIG_fail;
14994 temp3 = true;
14995 }
14996 if (obj3) {
14997 ecode4 = SWIG_AsVal_int(obj3, &val4);
14998 if (!SWIG_IsOK(ecode4)) {
14999 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15000 }
15001 arg4 = static_cast< int >(val4);
15002 }
15003 {
15004 PyThreadState* __tstate = wxPyBeginAllowThreads();
15005 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15006 wxPyEndAllowThreads(__tstate);
15007 if (PyErr_Occurred()) SWIG_fail;
15008 }
15009 {
15010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15011 }
15012 {
15013 if (created2) delete arg2;
15014 }
15015 {
15016 if (temp3)
15017 delete arg3;
15018 }
15019 return resultobj;
15020 fail:
15021 {
15022 if (created2) delete arg2;
15023 }
15024 {
15025 if (temp3)
15026 delete arg3;
15027 }
15028 return NULL;
15029 }
15030
15031
15032 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15033 PyObject *resultobj = 0;
15034 wxImage *arg1 = (wxImage *) 0 ;
15035 bool result;
15036 void *argp1 = 0 ;
15037 int res1 = 0 ;
15038 PyObject *swig_obj[1] ;
15039
15040 if (!args) SWIG_fail;
15041 swig_obj[0] = args;
15042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15043 if (!SWIG_IsOK(res1)) {
15044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15045 }
15046 arg1 = reinterpret_cast< wxImage * >(argp1);
15047 {
15048 PyThreadState* __tstate = wxPyBeginAllowThreads();
15049 result = (bool)(arg1)->Ok();
15050 wxPyEndAllowThreads(__tstate);
15051 if (PyErr_Occurred()) SWIG_fail;
15052 }
15053 {
15054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15055 }
15056 return resultobj;
15057 fail:
15058 return NULL;
15059 }
15060
15061
15062 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15063 PyObject *resultobj = 0;
15064 wxImage *arg1 = (wxImage *) 0 ;
15065 int result;
15066 void *argp1 = 0 ;
15067 int res1 = 0 ;
15068 PyObject *swig_obj[1] ;
15069
15070 if (!args) SWIG_fail;
15071 swig_obj[0] = args;
15072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15073 if (!SWIG_IsOK(res1)) {
15074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15075 }
15076 arg1 = reinterpret_cast< wxImage * >(argp1);
15077 {
15078 PyThreadState* __tstate = wxPyBeginAllowThreads();
15079 result = (int)(arg1)->GetWidth();
15080 wxPyEndAllowThreads(__tstate);
15081 if (PyErr_Occurred()) SWIG_fail;
15082 }
15083 resultobj = SWIG_From_int(static_cast< int >(result));
15084 return resultobj;
15085 fail:
15086 return NULL;
15087 }
15088
15089
15090 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15091 PyObject *resultobj = 0;
15092 wxImage *arg1 = (wxImage *) 0 ;
15093 int result;
15094 void *argp1 = 0 ;
15095 int res1 = 0 ;
15096 PyObject *swig_obj[1] ;
15097
15098 if (!args) SWIG_fail;
15099 swig_obj[0] = args;
15100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15101 if (!SWIG_IsOK(res1)) {
15102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15103 }
15104 arg1 = reinterpret_cast< wxImage * >(argp1);
15105 {
15106 PyThreadState* __tstate = wxPyBeginAllowThreads();
15107 result = (int)(arg1)->GetHeight();
15108 wxPyEndAllowThreads(__tstate);
15109 if (PyErr_Occurred()) SWIG_fail;
15110 }
15111 resultobj = SWIG_From_int(static_cast< int >(result));
15112 return resultobj;
15113 fail:
15114 return NULL;
15115 }
15116
15117
15118 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15119 PyObject *resultobj = 0;
15120 wxImage *arg1 = (wxImage *) 0 ;
15121 wxSize result;
15122 void *argp1 = 0 ;
15123 int res1 = 0 ;
15124 PyObject *swig_obj[1] ;
15125
15126 if (!args) SWIG_fail;
15127 swig_obj[0] = args;
15128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15129 if (!SWIG_IsOK(res1)) {
15130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15131 }
15132 arg1 = reinterpret_cast< wxImage * >(argp1);
15133 {
15134 PyThreadState* __tstate = wxPyBeginAllowThreads();
15135 result = wxImage_GetSize(arg1);
15136 wxPyEndAllowThreads(__tstate);
15137 if (PyErr_Occurred()) SWIG_fail;
15138 }
15139 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15140 return resultobj;
15141 fail:
15142 return NULL;
15143 }
15144
15145
15146 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15147 PyObject *resultobj = 0;
15148 wxImage *arg1 = (wxImage *) 0 ;
15149 wxRect *arg2 = 0 ;
15150 SwigValueWrapper<wxImage > result;
15151 void *argp1 = 0 ;
15152 int res1 = 0 ;
15153 wxRect temp2 ;
15154 PyObject * obj0 = 0 ;
15155 PyObject * obj1 = 0 ;
15156 char * kwnames[] = {
15157 (char *) "self",(char *) "rect", NULL
15158 };
15159
15160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15162 if (!SWIG_IsOK(res1)) {
15163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15164 }
15165 arg1 = reinterpret_cast< wxImage * >(argp1);
15166 {
15167 arg2 = &temp2;
15168 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15169 }
15170 {
15171 PyThreadState* __tstate = wxPyBeginAllowThreads();
15172 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15173 wxPyEndAllowThreads(__tstate);
15174 if (PyErr_Occurred()) SWIG_fail;
15175 }
15176 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15177 return resultobj;
15178 fail:
15179 return NULL;
15180 }
15181
15182
15183 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15184 PyObject *resultobj = 0;
15185 wxImage *arg1 = (wxImage *) 0 ;
15186 wxSize *arg2 = 0 ;
15187 wxPoint *arg3 = 0 ;
15188 int arg4 = (int) -1 ;
15189 int arg5 = (int) -1 ;
15190 int arg6 = (int) -1 ;
15191 SwigValueWrapper<wxImage > result;
15192 void *argp1 = 0 ;
15193 int res1 = 0 ;
15194 wxSize temp2 ;
15195 wxPoint temp3 ;
15196 int val4 ;
15197 int ecode4 = 0 ;
15198 int val5 ;
15199 int ecode5 = 0 ;
15200 int val6 ;
15201 int ecode6 = 0 ;
15202 PyObject * obj0 = 0 ;
15203 PyObject * obj1 = 0 ;
15204 PyObject * obj2 = 0 ;
15205 PyObject * obj3 = 0 ;
15206 PyObject * obj4 = 0 ;
15207 PyObject * obj5 = 0 ;
15208 char * kwnames[] = {
15209 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15210 };
15211
15212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15214 if (!SWIG_IsOK(res1)) {
15215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15216 }
15217 arg1 = reinterpret_cast< wxImage * >(argp1);
15218 {
15219 arg2 = &temp2;
15220 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15221 }
15222 {
15223 arg3 = &temp3;
15224 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15225 }
15226 if (obj3) {
15227 ecode4 = SWIG_AsVal_int(obj3, &val4);
15228 if (!SWIG_IsOK(ecode4)) {
15229 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15230 }
15231 arg4 = static_cast< int >(val4);
15232 }
15233 if (obj4) {
15234 ecode5 = SWIG_AsVal_int(obj4, &val5);
15235 if (!SWIG_IsOK(ecode5)) {
15236 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15237 }
15238 arg5 = static_cast< int >(val5);
15239 }
15240 if (obj5) {
15241 ecode6 = SWIG_AsVal_int(obj5, &val6);
15242 if (!SWIG_IsOK(ecode6)) {
15243 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15244 }
15245 arg6 = static_cast< int >(val6);
15246 }
15247 {
15248 PyThreadState* __tstate = wxPyBeginAllowThreads();
15249 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15250 wxPyEndAllowThreads(__tstate);
15251 if (PyErr_Occurred()) SWIG_fail;
15252 }
15253 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15254 return resultobj;
15255 fail:
15256 return NULL;
15257 }
15258
15259
15260 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15261 PyObject *resultobj = 0;
15262 wxImage *arg1 = (wxImage *) 0 ;
15263 SwigValueWrapper<wxImage > result;
15264 void *argp1 = 0 ;
15265 int res1 = 0 ;
15266 PyObject *swig_obj[1] ;
15267
15268 if (!args) SWIG_fail;
15269 swig_obj[0] = args;
15270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15271 if (!SWIG_IsOK(res1)) {
15272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15273 }
15274 arg1 = reinterpret_cast< wxImage * >(argp1);
15275 {
15276 PyThreadState* __tstate = wxPyBeginAllowThreads();
15277 result = (arg1)->Copy();
15278 wxPyEndAllowThreads(__tstate);
15279 if (PyErr_Occurred()) SWIG_fail;
15280 }
15281 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15282 return resultobj;
15283 fail:
15284 return NULL;
15285 }
15286
15287
15288 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15289 PyObject *resultobj = 0;
15290 wxImage *arg1 = (wxImage *) 0 ;
15291 wxImage *arg2 = 0 ;
15292 int arg3 ;
15293 int arg4 ;
15294 void *argp1 = 0 ;
15295 int res1 = 0 ;
15296 void *argp2 = 0 ;
15297 int res2 = 0 ;
15298 int val3 ;
15299 int ecode3 = 0 ;
15300 int val4 ;
15301 int ecode4 = 0 ;
15302 PyObject * obj0 = 0 ;
15303 PyObject * obj1 = 0 ;
15304 PyObject * obj2 = 0 ;
15305 PyObject * obj3 = 0 ;
15306 char * kwnames[] = {
15307 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15308 };
15309
15310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15312 if (!SWIG_IsOK(res1)) {
15313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15314 }
15315 arg1 = reinterpret_cast< wxImage * >(argp1);
15316 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15317 if (!SWIG_IsOK(res2)) {
15318 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15319 }
15320 if (!argp2) {
15321 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15322 }
15323 arg2 = reinterpret_cast< wxImage * >(argp2);
15324 ecode3 = SWIG_AsVal_int(obj2, &val3);
15325 if (!SWIG_IsOK(ecode3)) {
15326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15327 }
15328 arg3 = static_cast< int >(val3);
15329 ecode4 = SWIG_AsVal_int(obj3, &val4);
15330 if (!SWIG_IsOK(ecode4)) {
15331 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15332 }
15333 arg4 = static_cast< int >(val4);
15334 {
15335 PyThreadState* __tstate = wxPyBeginAllowThreads();
15336 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
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_GetData(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_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15360 }
15361 arg1 = reinterpret_cast< wxImage * >(argp1);
15362 {
15363 PyThreadState* __tstate = wxPyBeginAllowThreads();
15364 result = (PyObject *)wxImage_GetData(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_SetData(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_SetData",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_SetData" "', 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_SetData(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_GetDataBuffer(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_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15423 }
15424 arg1 = reinterpret_cast< wxImage * >(argp1);
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 result = (PyObject *)wxImage_GetDataBuffer(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_SetDataBuffer(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 *) "data", NULL
15449 };
15450
15451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",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_SetDataBuffer" "', 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_SetDataBuffer(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_GetAlphaData(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_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15486 }
15487 arg1 = reinterpret_cast< wxImage * >(argp1);
15488 {
15489 PyThreadState* __tstate = wxPyBeginAllowThreads();
15490 result = (PyObject *)wxImage_GetAlphaData(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_SetAlphaData(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_SetAlphaData",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_SetAlphaData" "', 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_SetAlphaData(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_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15537 PyObject *resultobj = 0;
15538 wxImage *arg1 = (wxImage *) 0 ;
15539 PyObject *result = 0 ;
15540 void *argp1 = 0 ;
15541 int res1 = 0 ;
15542 PyObject *swig_obj[1] ;
15543
15544 if (!args) SWIG_fail;
15545 swig_obj[0] = args;
15546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15547 if (!SWIG_IsOK(res1)) {
15548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15549 }
15550 arg1 = reinterpret_cast< wxImage * >(argp1);
15551 {
15552 PyThreadState* __tstate = wxPyBeginAllowThreads();
15553 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15554 wxPyEndAllowThreads(__tstate);
15555 if (PyErr_Occurred()) SWIG_fail;
15556 }
15557 resultobj = result;
15558 return resultobj;
15559 fail:
15560 return NULL;
15561 }
15562
15563
15564 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15565 PyObject *resultobj = 0;
15566 wxImage *arg1 = (wxImage *) 0 ;
15567 buffer arg2 ;
15568 int arg3 ;
15569 void *argp1 = 0 ;
15570 int res1 = 0 ;
15571 PyObject * obj0 = 0 ;
15572 PyObject * obj1 = 0 ;
15573 char * kwnames[] = {
15574 (char *) "self",(char *) "alpha", NULL
15575 };
15576
15577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15579 if (!SWIG_IsOK(res1)) {
15580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15581 }
15582 arg1 = reinterpret_cast< wxImage * >(argp1);
15583 {
15584 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15585 }
15586 {
15587 PyThreadState* __tstate = wxPyBeginAllowThreads();
15588 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15589 wxPyEndAllowThreads(__tstate);
15590 if (PyErr_Occurred()) SWIG_fail;
15591 }
15592 resultobj = SWIG_Py_Void();
15593 return resultobj;
15594 fail:
15595 return NULL;
15596 }
15597
15598
15599 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15600 PyObject *resultobj = 0;
15601 wxImage *arg1 = (wxImage *) 0 ;
15602 byte arg2 ;
15603 byte arg3 ;
15604 byte arg4 ;
15605 void *argp1 = 0 ;
15606 int res1 = 0 ;
15607 unsigned char val2 ;
15608 int ecode2 = 0 ;
15609 unsigned char val3 ;
15610 int ecode3 = 0 ;
15611 unsigned char val4 ;
15612 int ecode4 = 0 ;
15613 PyObject * obj0 = 0 ;
15614 PyObject * obj1 = 0 ;
15615 PyObject * obj2 = 0 ;
15616 PyObject * obj3 = 0 ;
15617 char * kwnames[] = {
15618 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15619 };
15620
15621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15623 if (!SWIG_IsOK(res1)) {
15624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15625 }
15626 arg1 = reinterpret_cast< wxImage * >(argp1);
15627 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15628 if (!SWIG_IsOK(ecode2)) {
15629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15630 }
15631 arg2 = static_cast< byte >(val2);
15632 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15633 if (!SWIG_IsOK(ecode3)) {
15634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15635 }
15636 arg3 = static_cast< byte >(val3);
15637 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15638 if (!SWIG_IsOK(ecode4)) {
15639 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15640 }
15641 arg4 = static_cast< byte >(val4);
15642 {
15643 PyThreadState* __tstate = wxPyBeginAllowThreads();
15644 (arg1)->SetMaskColour(arg2,arg3,arg4);
15645 wxPyEndAllowThreads(__tstate);
15646 if (PyErr_Occurred()) SWIG_fail;
15647 }
15648 resultobj = SWIG_Py_Void();
15649 return resultobj;
15650 fail:
15651 return NULL;
15652 }
15653
15654
15655 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15656 PyObject *resultobj = 0;
15657 wxImage *arg1 = (wxImage *) 0 ;
15658 byte *arg2 = (byte *) 0 ;
15659 byte *arg3 = (byte *) 0 ;
15660 byte *arg4 = (byte *) 0 ;
15661 void *argp1 = 0 ;
15662 int res1 = 0 ;
15663 byte temp2 ;
15664 int res2 = SWIG_TMPOBJ ;
15665 byte temp3 ;
15666 int res3 = SWIG_TMPOBJ ;
15667 byte temp4 ;
15668 int res4 = SWIG_TMPOBJ ;
15669 PyObject *swig_obj[1] ;
15670
15671 arg2 = &temp2;
15672 arg3 = &temp3;
15673 arg4 = &temp4;
15674 if (!args) SWIG_fail;
15675 swig_obj[0] = args;
15676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15677 if (!SWIG_IsOK(res1)) {
15678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15679 }
15680 arg1 = reinterpret_cast< wxImage * >(argp1);
15681 {
15682 PyThreadState* __tstate = wxPyBeginAllowThreads();
15683 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15684 wxPyEndAllowThreads(__tstate);
15685 if (PyErr_Occurred()) SWIG_fail;
15686 }
15687 resultobj = SWIG_Py_Void();
15688 if (SWIG_IsTmpObj(res2)) {
15689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15690 } else {
15691 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15692 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15693 }
15694 if (SWIG_IsTmpObj(res3)) {
15695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15696 } else {
15697 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15699 }
15700 if (SWIG_IsTmpObj(res4)) {
15701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15702 } else {
15703 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15705 }
15706 return resultobj;
15707 fail:
15708 return NULL;
15709 }
15710
15711
15712 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15713 PyObject *resultobj = 0;
15714 wxImage *arg1 = (wxImage *) 0 ;
15715 byte result;
15716 void *argp1 = 0 ;
15717 int res1 = 0 ;
15718 PyObject *swig_obj[1] ;
15719
15720 if (!args) SWIG_fail;
15721 swig_obj[0] = args;
15722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15723 if (!SWIG_IsOK(res1)) {
15724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15725 }
15726 arg1 = reinterpret_cast< wxImage * >(argp1);
15727 {
15728 PyThreadState* __tstate = wxPyBeginAllowThreads();
15729 result = (byte)(arg1)->GetMaskRed();
15730 wxPyEndAllowThreads(__tstate);
15731 if (PyErr_Occurred()) SWIG_fail;
15732 }
15733 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15734 return resultobj;
15735 fail:
15736 return NULL;
15737 }
15738
15739
15740 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15741 PyObject *resultobj = 0;
15742 wxImage *arg1 = (wxImage *) 0 ;
15743 byte result;
15744 void *argp1 = 0 ;
15745 int res1 = 0 ;
15746 PyObject *swig_obj[1] ;
15747
15748 if (!args) SWIG_fail;
15749 swig_obj[0] = args;
15750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15751 if (!SWIG_IsOK(res1)) {
15752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15753 }
15754 arg1 = reinterpret_cast< wxImage * >(argp1);
15755 {
15756 PyThreadState* __tstate = wxPyBeginAllowThreads();
15757 result = (byte)(arg1)->GetMaskGreen();
15758 wxPyEndAllowThreads(__tstate);
15759 if (PyErr_Occurred()) SWIG_fail;
15760 }
15761 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15762 return resultobj;
15763 fail:
15764 return NULL;
15765 }
15766
15767
15768 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15769 PyObject *resultobj = 0;
15770 wxImage *arg1 = (wxImage *) 0 ;
15771 byte result;
15772 void *argp1 = 0 ;
15773 int res1 = 0 ;
15774 PyObject *swig_obj[1] ;
15775
15776 if (!args) SWIG_fail;
15777 swig_obj[0] = args;
15778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15779 if (!SWIG_IsOK(res1)) {
15780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15781 }
15782 arg1 = reinterpret_cast< wxImage * >(argp1);
15783 {
15784 PyThreadState* __tstate = wxPyBeginAllowThreads();
15785 result = (byte)(arg1)->GetMaskBlue();
15786 wxPyEndAllowThreads(__tstate);
15787 if (PyErr_Occurred()) SWIG_fail;
15788 }
15789 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15790 return resultobj;
15791 fail:
15792 return NULL;
15793 }
15794
15795
15796 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15797 PyObject *resultobj = 0;
15798 wxImage *arg1 = (wxImage *) 0 ;
15799 bool arg2 = (bool) true ;
15800 void *argp1 = 0 ;
15801 int res1 = 0 ;
15802 bool val2 ;
15803 int ecode2 = 0 ;
15804 PyObject * obj0 = 0 ;
15805 PyObject * obj1 = 0 ;
15806 char * kwnames[] = {
15807 (char *) "self",(char *) "mask", NULL
15808 };
15809
15810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15812 if (!SWIG_IsOK(res1)) {
15813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15814 }
15815 arg1 = reinterpret_cast< wxImage * >(argp1);
15816 if (obj1) {
15817 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15818 if (!SWIG_IsOK(ecode2)) {
15819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15820 }
15821 arg2 = static_cast< bool >(val2);
15822 }
15823 {
15824 PyThreadState* __tstate = wxPyBeginAllowThreads();
15825 (arg1)->SetMask(arg2);
15826 wxPyEndAllowThreads(__tstate);
15827 if (PyErr_Occurred()) SWIG_fail;
15828 }
15829 resultobj = SWIG_Py_Void();
15830 return resultobj;
15831 fail:
15832 return NULL;
15833 }
15834
15835
15836 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15837 PyObject *resultobj = 0;
15838 wxImage *arg1 = (wxImage *) 0 ;
15839 bool result;
15840 void *argp1 = 0 ;
15841 int res1 = 0 ;
15842 PyObject *swig_obj[1] ;
15843
15844 if (!args) SWIG_fail;
15845 swig_obj[0] = args;
15846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15847 if (!SWIG_IsOK(res1)) {
15848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15849 }
15850 arg1 = reinterpret_cast< wxImage * >(argp1);
15851 {
15852 PyThreadState* __tstate = wxPyBeginAllowThreads();
15853 result = (bool)(arg1)->HasMask();
15854 wxPyEndAllowThreads(__tstate);
15855 if (PyErr_Occurred()) SWIG_fail;
15856 }
15857 {
15858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15859 }
15860 return resultobj;
15861 fail:
15862 return NULL;
15863 }
15864
15865
15866 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15867 PyObject *resultobj = 0;
15868 wxImage *arg1 = (wxImage *) 0 ;
15869 double arg2 ;
15870 wxPoint *arg3 = 0 ;
15871 bool arg4 = (bool) true ;
15872 wxPoint *arg5 = (wxPoint *) NULL ;
15873 SwigValueWrapper<wxImage > result;
15874 void *argp1 = 0 ;
15875 int res1 = 0 ;
15876 double val2 ;
15877 int ecode2 = 0 ;
15878 wxPoint temp3 ;
15879 bool val4 ;
15880 int ecode4 = 0 ;
15881 void *argp5 = 0 ;
15882 int res5 = 0 ;
15883 PyObject * obj0 = 0 ;
15884 PyObject * obj1 = 0 ;
15885 PyObject * obj2 = 0 ;
15886 PyObject * obj3 = 0 ;
15887 PyObject * obj4 = 0 ;
15888 char * kwnames[] = {
15889 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15890 };
15891
15892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15894 if (!SWIG_IsOK(res1)) {
15895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15896 }
15897 arg1 = reinterpret_cast< wxImage * >(argp1);
15898 ecode2 = SWIG_AsVal_double(obj1, &val2);
15899 if (!SWIG_IsOK(ecode2)) {
15900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15901 }
15902 arg2 = static_cast< double >(val2);
15903 {
15904 arg3 = &temp3;
15905 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15906 }
15907 if (obj3) {
15908 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15909 if (!SWIG_IsOK(ecode4)) {
15910 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15911 }
15912 arg4 = static_cast< bool >(val4);
15913 }
15914 if (obj4) {
15915 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15916 if (!SWIG_IsOK(res5)) {
15917 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15918 }
15919 arg5 = reinterpret_cast< wxPoint * >(argp5);
15920 }
15921 {
15922 PyThreadState* __tstate = wxPyBeginAllowThreads();
15923 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15924 wxPyEndAllowThreads(__tstate);
15925 if (PyErr_Occurred()) SWIG_fail;
15926 }
15927 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15928 return resultobj;
15929 fail:
15930 return NULL;
15931 }
15932
15933
15934 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15935 PyObject *resultobj = 0;
15936 wxImage *arg1 = (wxImage *) 0 ;
15937 bool arg2 = (bool) true ;
15938 SwigValueWrapper<wxImage > result;
15939 void *argp1 = 0 ;
15940 int res1 = 0 ;
15941 bool val2 ;
15942 int ecode2 = 0 ;
15943 PyObject * obj0 = 0 ;
15944 PyObject * obj1 = 0 ;
15945 char * kwnames[] = {
15946 (char *) "self",(char *) "clockwise", NULL
15947 };
15948
15949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15951 if (!SWIG_IsOK(res1)) {
15952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15953 }
15954 arg1 = reinterpret_cast< wxImage * >(argp1);
15955 if (obj1) {
15956 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15957 if (!SWIG_IsOK(ecode2)) {
15958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15959 }
15960 arg2 = static_cast< bool >(val2);
15961 }
15962 {
15963 PyThreadState* __tstate = wxPyBeginAllowThreads();
15964 result = (arg1)->Rotate90(arg2);
15965 wxPyEndAllowThreads(__tstate);
15966 if (PyErr_Occurred()) SWIG_fail;
15967 }
15968 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15969 return resultobj;
15970 fail:
15971 return NULL;
15972 }
15973
15974
15975 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15976 PyObject *resultobj = 0;
15977 wxImage *arg1 = (wxImage *) 0 ;
15978 bool arg2 = (bool) true ;
15979 SwigValueWrapper<wxImage > result;
15980 void *argp1 = 0 ;
15981 int res1 = 0 ;
15982 bool val2 ;
15983 int ecode2 = 0 ;
15984 PyObject * obj0 = 0 ;
15985 PyObject * obj1 = 0 ;
15986 char * kwnames[] = {
15987 (char *) "self",(char *) "horizontally", NULL
15988 };
15989
15990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15992 if (!SWIG_IsOK(res1)) {
15993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15994 }
15995 arg1 = reinterpret_cast< wxImage * >(argp1);
15996 if (obj1) {
15997 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15998 if (!SWIG_IsOK(ecode2)) {
15999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16000 }
16001 arg2 = static_cast< bool >(val2);
16002 }
16003 {
16004 PyThreadState* __tstate = wxPyBeginAllowThreads();
16005 result = (arg1)->Mirror(arg2);
16006 wxPyEndAllowThreads(__tstate);
16007 if (PyErr_Occurred()) SWIG_fail;
16008 }
16009 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16010 return resultobj;
16011 fail:
16012 return NULL;
16013 }
16014
16015
16016 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16017 PyObject *resultobj = 0;
16018 wxImage *arg1 = (wxImage *) 0 ;
16019 byte arg2 ;
16020 byte arg3 ;
16021 byte arg4 ;
16022 byte arg5 ;
16023 byte arg6 ;
16024 byte arg7 ;
16025 void *argp1 = 0 ;
16026 int res1 = 0 ;
16027 unsigned char val2 ;
16028 int ecode2 = 0 ;
16029 unsigned char val3 ;
16030 int ecode3 = 0 ;
16031 unsigned char val4 ;
16032 int ecode4 = 0 ;
16033 unsigned char val5 ;
16034 int ecode5 = 0 ;
16035 unsigned char val6 ;
16036 int ecode6 = 0 ;
16037 unsigned char val7 ;
16038 int ecode7 = 0 ;
16039 PyObject * obj0 = 0 ;
16040 PyObject * obj1 = 0 ;
16041 PyObject * obj2 = 0 ;
16042 PyObject * obj3 = 0 ;
16043 PyObject * obj4 = 0 ;
16044 PyObject * obj5 = 0 ;
16045 PyObject * obj6 = 0 ;
16046 char * kwnames[] = {
16047 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16048 };
16049
16050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16052 if (!SWIG_IsOK(res1)) {
16053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16054 }
16055 arg1 = reinterpret_cast< wxImage * >(argp1);
16056 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16057 if (!SWIG_IsOK(ecode2)) {
16058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16059 }
16060 arg2 = static_cast< byte >(val2);
16061 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16062 if (!SWIG_IsOK(ecode3)) {
16063 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16064 }
16065 arg3 = static_cast< byte >(val3);
16066 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16067 if (!SWIG_IsOK(ecode4)) {
16068 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16069 }
16070 arg4 = static_cast< byte >(val4);
16071 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16072 if (!SWIG_IsOK(ecode5)) {
16073 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16074 }
16075 arg5 = static_cast< byte >(val5);
16076 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16077 if (!SWIG_IsOK(ecode6)) {
16078 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16079 }
16080 arg6 = static_cast< byte >(val6);
16081 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16082 if (!SWIG_IsOK(ecode7)) {
16083 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16084 }
16085 arg7 = static_cast< byte >(val7);
16086 {
16087 PyThreadState* __tstate = wxPyBeginAllowThreads();
16088 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16089 wxPyEndAllowThreads(__tstate);
16090 if (PyErr_Occurred()) SWIG_fail;
16091 }
16092 resultobj = SWIG_Py_Void();
16093 return resultobj;
16094 fail:
16095 return NULL;
16096 }
16097
16098
16099 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16100 PyObject *resultobj = 0;
16101 wxImage *arg1 = (wxImage *) 0 ;
16102 double arg2 = (double) 0.299 ;
16103 double arg3 = (double) 0.587 ;
16104 double arg4 = (double) 0.114 ;
16105 SwigValueWrapper<wxImage > result;
16106 void *argp1 = 0 ;
16107 int res1 = 0 ;
16108 double val2 ;
16109 int ecode2 = 0 ;
16110 double val3 ;
16111 int ecode3 = 0 ;
16112 double 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 *) "lr",(char *) "lg",(char *) "lb", NULL
16120 };
16121
16122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",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_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16126 }
16127 arg1 = reinterpret_cast< wxImage * >(argp1);
16128 if (obj1) {
16129 ecode2 = SWIG_AsVal_double(obj1, &val2);
16130 if (!SWIG_IsOK(ecode2)) {
16131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16132 }
16133 arg2 = static_cast< double >(val2);
16134 }
16135 if (obj2) {
16136 ecode3 = SWIG_AsVal_double(obj2, &val3);
16137 if (!SWIG_IsOK(ecode3)) {
16138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16139 }
16140 arg3 = static_cast< double >(val3);
16141 }
16142 if (obj3) {
16143 ecode4 = SWIG_AsVal_double(obj3, &val4);
16144 if (!SWIG_IsOK(ecode4)) {
16145 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16146 }
16147 arg4 = static_cast< double >(val4);
16148 }
16149 {
16150 PyThreadState* __tstate = wxPyBeginAllowThreads();
16151 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16152 wxPyEndAllowThreads(__tstate);
16153 if (PyErr_Occurred()) SWIG_fail;
16154 }
16155 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16156 return resultobj;
16157 fail:
16158 return NULL;
16159 }
16160
16161
16162 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16163 PyObject *resultobj = 0;
16164 wxImage *arg1 = (wxImage *) 0 ;
16165 byte arg2 ;
16166 byte arg3 ;
16167 byte arg4 ;
16168 SwigValueWrapper<wxImage > result;
16169 void *argp1 = 0 ;
16170 int res1 = 0 ;
16171 unsigned char val2 ;
16172 int ecode2 = 0 ;
16173 unsigned char val3 ;
16174 int ecode3 = 0 ;
16175 unsigned char val4 ;
16176 int ecode4 = 0 ;
16177 PyObject * obj0 = 0 ;
16178 PyObject * obj1 = 0 ;
16179 PyObject * obj2 = 0 ;
16180 PyObject * obj3 = 0 ;
16181 char * kwnames[] = {
16182 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16183 };
16184
16185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16187 if (!SWIG_IsOK(res1)) {
16188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16189 }
16190 arg1 = reinterpret_cast< wxImage * >(argp1);
16191 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16192 if (!SWIG_IsOK(ecode2)) {
16193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16194 }
16195 arg2 = static_cast< byte >(val2);
16196 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16197 if (!SWIG_IsOK(ecode3)) {
16198 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16199 }
16200 arg3 = static_cast< byte >(val3);
16201 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16202 if (!SWIG_IsOK(ecode4)) {
16203 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16204 }
16205 arg4 = static_cast< byte >(val4);
16206 {
16207 PyThreadState* __tstate = wxPyBeginAllowThreads();
16208 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16209 wxPyEndAllowThreads(__tstate);
16210 if (PyErr_Occurred()) SWIG_fail;
16211 }
16212 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16213 return resultobj;
16214 fail:
16215 return NULL;
16216 }
16217
16218
16219 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16220 PyObject *resultobj = 0;
16221 wxImage *arg1 = (wxImage *) 0 ;
16222 wxString *arg2 = 0 ;
16223 wxString *arg3 = 0 ;
16224 void *argp1 = 0 ;
16225 int res1 = 0 ;
16226 bool temp2 = false ;
16227 bool temp3 = false ;
16228 PyObject * obj0 = 0 ;
16229 PyObject * obj1 = 0 ;
16230 PyObject * obj2 = 0 ;
16231 char * kwnames[] = {
16232 (char *) "self",(char *) "name",(char *) "value", NULL
16233 };
16234
16235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16237 if (!SWIG_IsOK(res1)) {
16238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16239 }
16240 arg1 = reinterpret_cast< wxImage * >(argp1);
16241 {
16242 arg2 = wxString_in_helper(obj1);
16243 if (arg2 == NULL) SWIG_fail;
16244 temp2 = true;
16245 }
16246 {
16247 arg3 = wxString_in_helper(obj2);
16248 if (arg3 == NULL) SWIG_fail;
16249 temp3 = true;
16250 }
16251 {
16252 PyThreadState* __tstate = wxPyBeginAllowThreads();
16253 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16254 wxPyEndAllowThreads(__tstate);
16255 if (PyErr_Occurred()) SWIG_fail;
16256 }
16257 resultobj = SWIG_Py_Void();
16258 {
16259 if (temp2)
16260 delete arg2;
16261 }
16262 {
16263 if (temp3)
16264 delete arg3;
16265 }
16266 return resultobj;
16267 fail:
16268 {
16269 if (temp2)
16270 delete arg2;
16271 }
16272 {
16273 if (temp3)
16274 delete arg3;
16275 }
16276 return NULL;
16277 }
16278
16279
16280 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16281 PyObject *resultobj = 0;
16282 wxImage *arg1 = (wxImage *) 0 ;
16283 wxString *arg2 = 0 ;
16284 int arg3 ;
16285 void *argp1 = 0 ;
16286 int res1 = 0 ;
16287 bool temp2 = false ;
16288 int val3 ;
16289 int ecode3 = 0 ;
16290 PyObject * obj0 = 0 ;
16291 PyObject * obj1 = 0 ;
16292 PyObject * obj2 = 0 ;
16293 char * kwnames[] = {
16294 (char *) "self",(char *) "name",(char *) "value", NULL
16295 };
16296
16297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16299 if (!SWIG_IsOK(res1)) {
16300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16301 }
16302 arg1 = reinterpret_cast< wxImage * >(argp1);
16303 {
16304 arg2 = wxString_in_helper(obj1);
16305 if (arg2 == NULL) SWIG_fail;
16306 temp2 = true;
16307 }
16308 ecode3 = SWIG_AsVal_int(obj2, &val3);
16309 if (!SWIG_IsOK(ecode3)) {
16310 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16311 }
16312 arg3 = static_cast< int >(val3);
16313 {
16314 PyThreadState* __tstate = wxPyBeginAllowThreads();
16315 (arg1)->SetOption((wxString const &)*arg2,arg3);
16316 wxPyEndAllowThreads(__tstate);
16317 if (PyErr_Occurred()) SWIG_fail;
16318 }
16319 resultobj = SWIG_Py_Void();
16320 {
16321 if (temp2)
16322 delete arg2;
16323 }
16324 return resultobj;
16325 fail:
16326 {
16327 if (temp2)
16328 delete arg2;
16329 }
16330 return NULL;
16331 }
16332
16333
16334 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16335 PyObject *resultobj = 0;
16336 wxImage *arg1 = (wxImage *) 0 ;
16337 wxString *arg2 = 0 ;
16338 wxString result;
16339 void *argp1 = 0 ;
16340 int res1 = 0 ;
16341 bool temp2 = false ;
16342 PyObject * obj0 = 0 ;
16343 PyObject * obj1 = 0 ;
16344 char * kwnames[] = {
16345 (char *) "self",(char *) "name", NULL
16346 };
16347
16348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16350 if (!SWIG_IsOK(res1)) {
16351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16352 }
16353 arg1 = reinterpret_cast< wxImage * >(argp1);
16354 {
16355 arg2 = wxString_in_helper(obj1);
16356 if (arg2 == NULL) SWIG_fail;
16357 temp2 = true;
16358 }
16359 {
16360 PyThreadState* __tstate = wxPyBeginAllowThreads();
16361 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16362 wxPyEndAllowThreads(__tstate);
16363 if (PyErr_Occurred()) SWIG_fail;
16364 }
16365 {
16366 #if wxUSE_UNICODE
16367 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16368 #else
16369 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16370 #endif
16371 }
16372 {
16373 if (temp2)
16374 delete arg2;
16375 }
16376 return resultobj;
16377 fail:
16378 {
16379 if (temp2)
16380 delete arg2;
16381 }
16382 return NULL;
16383 }
16384
16385
16386 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16387 PyObject *resultobj = 0;
16388 wxImage *arg1 = (wxImage *) 0 ;
16389 wxString *arg2 = 0 ;
16390 int result;
16391 void *argp1 = 0 ;
16392 int res1 = 0 ;
16393 bool temp2 = false ;
16394 PyObject * obj0 = 0 ;
16395 PyObject * obj1 = 0 ;
16396 char * kwnames[] = {
16397 (char *) "self",(char *) "name", NULL
16398 };
16399
16400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16402 if (!SWIG_IsOK(res1)) {
16403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16404 }
16405 arg1 = reinterpret_cast< wxImage * >(argp1);
16406 {
16407 arg2 = wxString_in_helper(obj1);
16408 if (arg2 == NULL) SWIG_fail;
16409 temp2 = true;
16410 }
16411 {
16412 PyThreadState* __tstate = wxPyBeginAllowThreads();
16413 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16414 wxPyEndAllowThreads(__tstate);
16415 if (PyErr_Occurred()) SWIG_fail;
16416 }
16417 resultobj = SWIG_From_int(static_cast< int >(result));
16418 {
16419 if (temp2)
16420 delete arg2;
16421 }
16422 return resultobj;
16423 fail:
16424 {
16425 if (temp2)
16426 delete arg2;
16427 }
16428 return NULL;
16429 }
16430
16431
16432 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16433 PyObject *resultobj = 0;
16434 wxImage *arg1 = (wxImage *) 0 ;
16435 wxString *arg2 = 0 ;
16436 bool result;
16437 void *argp1 = 0 ;
16438 int res1 = 0 ;
16439 bool temp2 = false ;
16440 PyObject * obj0 = 0 ;
16441 PyObject * obj1 = 0 ;
16442 char * kwnames[] = {
16443 (char *) "self",(char *) "name", NULL
16444 };
16445
16446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16448 if (!SWIG_IsOK(res1)) {
16449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16450 }
16451 arg1 = reinterpret_cast< wxImage * >(argp1);
16452 {
16453 arg2 = wxString_in_helper(obj1);
16454 if (arg2 == NULL) SWIG_fail;
16455 temp2 = true;
16456 }
16457 {
16458 PyThreadState* __tstate = wxPyBeginAllowThreads();
16459 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16460 wxPyEndAllowThreads(__tstate);
16461 if (PyErr_Occurred()) SWIG_fail;
16462 }
16463 {
16464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16465 }
16466 {
16467 if (temp2)
16468 delete arg2;
16469 }
16470 return resultobj;
16471 fail:
16472 {
16473 if (temp2)
16474 delete arg2;
16475 }
16476 return NULL;
16477 }
16478
16479
16480 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16481 PyObject *resultobj = 0;
16482 wxImage *arg1 = (wxImage *) 0 ;
16483 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16484 unsigned long result;
16485 void *argp1 = 0 ;
16486 int res1 = 0 ;
16487 unsigned long val2 ;
16488 int ecode2 = 0 ;
16489 PyObject * obj0 = 0 ;
16490 PyObject * obj1 = 0 ;
16491 char * kwnames[] = {
16492 (char *) "self",(char *) "stopafter", NULL
16493 };
16494
16495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16497 if (!SWIG_IsOK(res1)) {
16498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16499 }
16500 arg1 = reinterpret_cast< wxImage * >(argp1);
16501 if (obj1) {
16502 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16503 if (!SWIG_IsOK(ecode2)) {
16504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16505 }
16506 arg2 = static_cast< unsigned long >(val2);
16507 }
16508 {
16509 PyThreadState* __tstate = wxPyBeginAllowThreads();
16510 result = (unsigned long)(arg1)->CountColours(arg2);
16511 wxPyEndAllowThreads(__tstate);
16512 if (PyErr_Occurred()) SWIG_fail;
16513 }
16514 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16515 return resultobj;
16516 fail:
16517 return NULL;
16518 }
16519
16520
16521 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16522 PyObject *resultobj = 0;
16523 wxImage *arg1 = (wxImage *) 0 ;
16524 wxImageHistogram *arg2 = 0 ;
16525 unsigned long result;
16526 void *argp1 = 0 ;
16527 int res1 = 0 ;
16528 void *argp2 = 0 ;
16529 int res2 = 0 ;
16530 PyObject * obj0 = 0 ;
16531 PyObject * obj1 = 0 ;
16532 char * kwnames[] = {
16533 (char *) "self",(char *) "h", NULL
16534 };
16535
16536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16538 if (!SWIG_IsOK(res1)) {
16539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16540 }
16541 arg1 = reinterpret_cast< wxImage * >(argp1);
16542 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16543 if (!SWIG_IsOK(res2)) {
16544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16545 }
16546 if (!argp2) {
16547 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16548 }
16549 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16550 {
16551 PyThreadState* __tstate = wxPyBeginAllowThreads();
16552 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16553 wxPyEndAllowThreads(__tstate);
16554 if (PyErr_Occurred()) SWIG_fail;
16555 }
16556 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16557 return resultobj;
16558 fail:
16559 return NULL;
16560 }
16561
16562
16563 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16564 PyObject *resultobj = 0;
16565 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16566 void *argp1 = 0 ;
16567 int res1 = 0 ;
16568 PyObject * obj0 = 0 ;
16569 char * kwnames[] = {
16570 (char *) "handler", NULL
16571 };
16572
16573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16575 if (!SWIG_IsOK(res1)) {
16576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16577 }
16578 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16579 {
16580 PyThreadState* __tstate = wxPyBeginAllowThreads();
16581 wxImage::AddHandler(arg1);
16582 wxPyEndAllowThreads(__tstate);
16583 if (PyErr_Occurred()) SWIG_fail;
16584 }
16585 resultobj = SWIG_Py_Void();
16586 return resultobj;
16587 fail:
16588 return NULL;
16589 }
16590
16591
16592 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16593 PyObject *resultobj = 0;
16594 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16595 void *argp1 = 0 ;
16596 int res1 = 0 ;
16597 PyObject * obj0 = 0 ;
16598 char * kwnames[] = {
16599 (char *) "handler", NULL
16600 };
16601
16602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16604 if (!SWIG_IsOK(res1)) {
16605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16606 }
16607 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16608 {
16609 PyThreadState* __tstate = wxPyBeginAllowThreads();
16610 wxImage::InsertHandler(arg1);
16611 wxPyEndAllowThreads(__tstate);
16612 if (PyErr_Occurred()) SWIG_fail;
16613 }
16614 resultobj = SWIG_Py_Void();
16615 return resultobj;
16616 fail:
16617 return NULL;
16618 }
16619
16620
16621 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16622 PyObject *resultobj = 0;
16623 wxString *arg1 = 0 ;
16624 bool result;
16625 bool temp1 = false ;
16626 PyObject * obj0 = 0 ;
16627 char * kwnames[] = {
16628 (char *) "name", NULL
16629 };
16630
16631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16632 {
16633 arg1 = wxString_in_helper(obj0);
16634 if (arg1 == NULL) SWIG_fail;
16635 temp1 = true;
16636 }
16637 {
16638 PyThreadState* __tstate = wxPyBeginAllowThreads();
16639 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16640 wxPyEndAllowThreads(__tstate);
16641 if (PyErr_Occurred()) SWIG_fail;
16642 }
16643 {
16644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16645 }
16646 {
16647 if (temp1)
16648 delete arg1;
16649 }
16650 return resultobj;
16651 fail:
16652 {
16653 if (temp1)
16654 delete arg1;
16655 }
16656 return NULL;
16657 }
16658
16659
16660 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16661 PyObject *resultobj = 0;
16662 PyObject *result = 0 ;
16663
16664 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16665 {
16666 PyThreadState* __tstate = wxPyBeginAllowThreads();
16667 result = (PyObject *)wxImage_GetHandlers();
16668 wxPyEndAllowThreads(__tstate);
16669 if (PyErr_Occurred()) SWIG_fail;
16670 }
16671 resultobj = result;
16672 return resultobj;
16673 fail:
16674 return NULL;
16675 }
16676
16677
16678 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16679 PyObject *resultobj = 0;
16680 wxString result;
16681
16682 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16683 {
16684 PyThreadState* __tstate = wxPyBeginAllowThreads();
16685 result = wxImage::GetImageExtWildcard();
16686 wxPyEndAllowThreads(__tstate);
16687 if (PyErr_Occurred()) SWIG_fail;
16688 }
16689 {
16690 #if wxUSE_UNICODE
16691 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16692 #else
16693 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16694 #endif
16695 }
16696 return resultobj;
16697 fail:
16698 return NULL;
16699 }
16700
16701
16702 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16703 PyObject *resultobj = 0;
16704 wxImage *arg1 = (wxImage *) 0 ;
16705 int arg2 = (int) -1 ;
16706 wxBitmap result;
16707 void *argp1 = 0 ;
16708 int res1 = 0 ;
16709 int val2 ;
16710 int ecode2 = 0 ;
16711 PyObject * obj0 = 0 ;
16712 PyObject * obj1 = 0 ;
16713 char * kwnames[] = {
16714 (char *) "self",(char *) "depth", NULL
16715 };
16716
16717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16719 if (!SWIG_IsOK(res1)) {
16720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16721 }
16722 arg1 = reinterpret_cast< wxImage * >(argp1);
16723 if (obj1) {
16724 ecode2 = SWIG_AsVal_int(obj1, &val2);
16725 if (!SWIG_IsOK(ecode2)) {
16726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16727 }
16728 arg2 = static_cast< int >(val2);
16729 }
16730 {
16731 if (!wxPyCheckForApp()) SWIG_fail;
16732 PyThreadState* __tstate = wxPyBeginAllowThreads();
16733 result = wxImage_ConvertToBitmap(arg1,arg2);
16734 wxPyEndAllowThreads(__tstate);
16735 if (PyErr_Occurred()) SWIG_fail;
16736 }
16737 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16738 return resultobj;
16739 fail:
16740 return NULL;
16741 }
16742
16743
16744 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16745 PyObject *resultobj = 0;
16746 wxImage *arg1 = (wxImage *) 0 ;
16747 byte arg2 ;
16748 byte arg3 ;
16749 byte arg4 ;
16750 wxBitmap result;
16751 void *argp1 = 0 ;
16752 int res1 = 0 ;
16753 unsigned char val2 ;
16754 int ecode2 = 0 ;
16755 unsigned char val3 ;
16756 int ecode3 = 0 ;
16757 unsigned char val4 ;
16758 int ecode4 = 0 ;
16759 PyObject * obj0 = 0 ;
16760 PyObject * obj1 = 0 ;
16761 PyObject * obj2 = 0 ;
16762 PyObject * obj3 = 0 ;
16763 char * kwnames[] = {
16764 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16765 };
16766
16767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16769 if (!SWIG_IsOK(res1)) {
16770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16771 }
16772 arg1 = reinterpret_cast< wxImage * >(argp1);
16773 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16774 if (!SWIG_IsOK(ecode2)) {
16775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16776 }
16777 arg2 = static_cast< byte >(val2);
16778 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16779 if (!SWIG_IsOK(ecode3)) {
16780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16781 }
16782 arg3 = static_cast< byte >(val3);
16783 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16784 if (!SWIG_IsOK(ecode4)) {
16785 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16786 }
16787 arg4 = static_cast< byte >(val4);
16788 {
16789 if (!wxPyCheckForApp()) SWIG_fail;
16790 PyThreadState* __tstate = wxPyBeginAllowThreads();
16791 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16792 wxPyEndAllowThreads(__tstate);
16793 if (PyErr_Occurred()) SWIG_fail;
16794 }
16795 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16796 return resultobj;
16797 fail:
16798 return NULL;
16799 }
16800
16801
16802 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16803 PyObject *resultobj = 0;
16804 wxImage *arg1 = (wxImage *) 0 ;
16805 double arg2 ;
16806 void *argp1 = 0 ;
16807 int res1 = 0 ;
16808 double val2 ;
16809 int ecode2 = 0 ;
16810 PyObject * obj0 = 0 ;
16811 PyObject * obj1 = 0 ;
16812 char * kwnames[] = {
16813 (char *) "self",(char *) "angle", NULL
16814 };
16815
16816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16818 if (!SWIG_IsOK(res1)) {
16819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16820 }
16821 arg1 = reinterpret_cast< wxImage * >(argp1);
16822 ecode2 = SWIG_AsVal_double(obj1, &val2);
16823 if (!SWIG_IsOK(ecode2)) {
16824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16825 }
16826 arg2 = static_cast< double >(val2);
16827 {
16828 PyThreadState* __tstate = wxPyBeginAllowThreads();
16829 (arg1)->RotateHue(arg2);
16830 wxPyEndAllowThreads(__tstate);
16831 if (PyErr_Occurred()) SWIG_fail;
16832 }
16833 resultobj = SWIG_Py_Void();
16834 return resultobj;
16835 fail:
16836 return NULL;
16837 }
16838
16839
16840 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16841 PyObject *resultobj = 0;
16842 wxImage_RGBValue arg1 ;
16843 wxImage_HSVValue result;
16844 void *argp1 ;
16845 int res1 = 0 ;
16846 PyObject * obj0 = 0 ;
16847 char * kwnames[] = {
16848 (char *) "rgb", NULL
16849 };
16850
16851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16852 {
16853 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16854 if (!SWIG_IsOK(res1)) {
16855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16856 }
16857 if (!argp1) {
16858 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16859 } else {
16860 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16861 arg1 = *temp;
16862 if (SWIG_IsNewObj(res1)) delete temp;
16863 }
16864 }
16865 {
16866 PyThreadState* __tstate = wxPyBeginAllowThreads();
16867 result = wxImage::RGBtoHSV(arg1);
16868 wxPyEndAllowThreads(__tstate);
16869 if (PyErr_Occurred()) SWIG_fail;
16870 }
16871 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16872 return resultobj;
16873 fail:
16874 return NULL;
16875 }
16876
16877
16878 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16879 PyObject *resultobj = 0;
16880 wxImage_HSVValue arg1 ;
16881 wxImage_RGBValue result;
16882 void *argp1 ;
16883 int res1 = 0 ;
16884 PyObject * obj0 = 0 ;
16885 char * kwnames[] = {
16886 (char *) "hsv", NULL
16887 };
16888
16889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16890 {
16891 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16892 if (!SWIG_IsOK(res1)) {
16893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16894 }
16895 if (!argp1) {
16896 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16897 } else {
16898 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16899 arg1 = *temp;
16900 if (SWIG_IsNewObj(res1)) delete temp;
16901 }
16902 }
16903 {
16904 PyThreadState* __tstate = wxPyBeginAllowThreads();
16905 result = wxImage::HSVtoRGB(arg1);
16906 wxPyEndAllowThreads(__tstate);
16907 if (PyErr_Occurred()) SWIG_fail;
16908 }
16909 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16910 return resultobj;
16911 fail:
16912 return NULL;
16913 }
16914
16915
16916 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16917 PyObject *obj;
16918 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16919 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16920 return SWIG_Py_Void();
16921 }
16922
16923 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16924 return SWIG_Python_InitShadowInstance(args);
16925 }
16926
16927 SWIGINTERN int NullImage_set(PyObject *) {
16928 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16929 return 1;
16930 }
16931
16932
16933 SWIGINTERN PyObject *NullImage_get(void) {
16934 PyObject *pyobj = 0;
16935
16936 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16937 return pyobj;
16938 }
16939
16940
16941 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16942 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16943 return 1;
16944 }
16945
16946
16947 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16948 PyObject *pyobj = 0;
16949
16950 {
16951 #if wxUSE_UNICODE
16952 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16953 #else
16954 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16955 #endif
16956 }
16957 return pyobj;
16958 }
16959
16960
16961 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16962 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16963 return 1;
16964 }
16965
16966
16967 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16968 PyObject *pyobj = 0;
16969
16970 {
16971 #if wxUSE_UNICODE
16972 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16973 #else
16974 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16975 #endif
16976 }
16977 return pyobj;
16978 }
16979
16980
16981 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16982 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16983 return 1;
16984 }
16985
16986
16987 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16988 PyObject *pyobj = 0;
16989
16990 {
16991 #if wxUSE_UNICODE
16992 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16993 #else
16994 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16995 #endif
16996 }
16997 return pyobj;
16998 }
16999
17000
17001 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17002 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17003 return 1;
17004 }
17005
17006
17007 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17008 PyObject *pyobj = 0;
17009
17010 {
17011 #if wxUSE_UNICODE
17012 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17013 #else
17014 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17015 #endif
17016 }
17017 return pyobj;
17018 }
17019
17020
17021 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17022 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17023 return 1;
17024 }
17025
17026
17027 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17028 PyObject *pyobj = 0;
17029
17030 {
17031 #if wxUSE_UNICODE
17032 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17033 #else
17034 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17035 #endif
17036 }
17037 return pyobj;
17038 }
17039
17040
17041 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17042 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17043 return 1;
17044 }
17045
17046
17047 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17048 PyObject *pyobj = 0;
17049
17050 {
17051 #if wxUSE_UNICODE
17052 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17053 #else
17054 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17055 #endif
17056 }
17057 return pyobj;
17058 }
17059
17060
17061 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17062 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17063 return 1;
17064 }
17065
17066
17067 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17068 PyObject *pyobj = 0;
17069
17070 {
17071 #if wxUSE_UNICODE
17072 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17073 #else
17074 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17075 #endif
17076 }
17077 return pyobj;
17078 }
17079
17080
17081 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17082 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17083 return 1;
17084 }
17085
17086
17087 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17088 PyObject *pyobj = 0;
17089
17090 {
17091 #if wxUSE_UNICODE
17092 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17093 #else
17094 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17095 #endif
17096 }
17097 return pyobj;
17098 }
17099
17100
17101 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17102 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17103 return 1;
17104 }
17105
17106
17107 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17108 PyObject *pyobj = 0;
17109
17110 {
17111 #if wxUSE_UNICODE
17112 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17113 #else
17114 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17115 #endif
17116 }
17117 return pyobj;
17118 }
17119
17120
17121 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17122 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17123 return 1;
17124 }
17125
17126
17127 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17128 PyObject *pyobj = 0;
17129
17130 {
17131 #if wxUSE_UNICODE
17132 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17133 #else
17134 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17135 #endif
17136 }
17137 return pyobj;
17138 }
17139
17140
17141 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17142 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17143 return 1;
17144 }
17145
17146
17147 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17148 PyObject *pyobj = 0;
17149
17150 {
17151 #if wxUSE_UNICODE
17152 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17153 #else
17154 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17155 #endif
17156 }
17157 return pyobj;
17158 }
17159
17160
17161 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17162 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17163 return 1;
17164 }
17165
17166
17167 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17168 PyObject *pyobj = 0;
17169
17170 {
17171 #if wxUSE_UNICODE
17172 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17173 #else
17174 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17175 #endif
17176 }
17177 return pyobj;
17178 }
17179
17180
17181 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17182 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17183 return 1;
17184 }
17185
17186
17187 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17188 PyObject *pyobj = 0;
17189
17190 {
17191 #if wxUSE_UNICODE
17192 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17193 #else
17194 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17195 #endif
17196 }
17197 return pyobj;
17198 }
17199
17200
17201 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17202 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17203 return 1;
17204 }
17205
17206
17207 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17208 PyObject *pyobj = 0;
17209
17210 {
17211 #if wxUSE_UNICODE
17212 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17213 #else
17214 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17215 #endif
17216 }
17217 return pyobj;
17218 }
17219
17220
17221 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17222 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17223 return 1;
17224 }
17225
17226
17227 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17228 PyObject *pyobj = 0;
17229
17230 {
17231 #if wxUSE_UNICODE
17232 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17233 #else
17234 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17235 #endif
17236 }
17237 return pyobj;
17238 }
17239
17240
17241 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17242 PyObject *resultobj = 0;
17243 wxBMPHandler *result = 0 ;
17244
17245 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17246 {
17247 PyThreadState* __tstate = wxPyBeginAllowThreads();
17248 result = (wxBMPHandler *)new wxBMPHandler();
17249 wxPyEndAllowThreads(__tstate);
17250 if (PyErr_Occurred()) SWIG_fail;
17251 }
17252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17253 return resultobj;
17254 fail:
17255 return NULL;
17256 }
17257
17258
17259 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17260 PyObject *obj;
17261 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17262 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17263 return SWIG_Py_Void();
17264 }
17265
17266 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17267 return SWIG_Python_InitShadowInstance(args);
17268 }
17269
17270 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17271 PyObject *resultobj = 0;
17272 wxICOHandler *result = 0 ;
17273
17274 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17275 {
17276 PyThreadState* __tstate = wxPyBeginAllowThreads();
17277 result = (wxICOHandler *)new wxICOHandler();
17278 wxPyEndAllowThreads(__tstate);
17279 if (PyErr_Occurred()) SWIG_fail;
17280 }
17281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17282 return resultobj;
17283 fail:
17284 return NULL;
17285 }
17286
17287
17288 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17289 PyObject *obj;
17290 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17291 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17292 return SWIG_Py_Void();
17293 }
17294
17295 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17296 return SWIG_Python_InitShadowInstance(args);
17297 }
17298
17299 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17300 PyObject *resultobj = 0;
17301 wxCURHandler *result = 0 ;
17302
17303 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17304 {
17305 PyThreadState* __tstate = wxPyBeginAllowThreads();
17306 result = (wxCURHandler *)new wxCURHandler();
17307 wxPyEndAllowThreads(__tstate);
17308 if (PyErr_Occurred()) SWIG_fail;
17309 }
17310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17311 return resultobj;
17312 fail:
17313 return NULL;
17314 }
17315
17316
17317 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17318 PyObject *obj;
17319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17320 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17321 return SWIG_Py_Void();
17322 }
17323
17324 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17325 return SWIG_Python_InitShadowInstance(args);
17326 }
17327
17328 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17329 PyObject *resultobj = 0;
17330 wxANIHandler *result = 0 ;
17331
17332 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17333 {
17334 PyThreadState* __tstate = wxPyBeginAllowThreads();
17335 result = (wxANIHandler *)new wxANIHandler();
17336 wxPyEndAllowThreads(__tstate);
17337 if (PyErr_Occurred()) SWIG_fail;
17338 }
17339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17340 return resultobj;
17341 fail:
17342 return NULL;
17343 }
17344
17345
17346 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17347 PyObject *obj;
17348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17349 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17350 return SWIG_Py_Void();
17351 }
17352
17353 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17354 return SWIG_Python_InitShadowInstance(args);
17355 }
17356
17357 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17358 PyObject *resultobj = 0;
17359 wxPNGHandler *result = 0 ;
17360
17361 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17362 {
17363 PyThreadState* __tstate = wxPyBeginAllowThreads();
17364 result = (wxPNGHandler *)new wxPNGHandler();
17365 wxPyEndAllowThreads(__tstate);
17366 if (PyErr_Occurred()) SWIG_fail;
17367 }
17368 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17369 return resultobj;
17370 fail:
17371 return NULL;
17372 }
17373
17374
17375 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17376 PyObject *obj;
17377 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17378 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17379 return SWIG_Py_Void();
17380 }
17381
17382 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17383 return SWIG_Python_InitShadowInstance(args);
17384 }
17385
17386 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17387 PyObject *resultobj = 0;
17388 wxGIFHandler *result = 0 ;
17389
17390 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17391 {
17392 PyThreadState* __tstate = wxPyBeginAllowThreads();
17393 result = (wxGIFHandler *)new wxGIFHandler();
17394 wxPyEndAllowThreads(__tstate);
17395 if (PyErr_Occurred()) SWIG_fail;
17396 }
17397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17398 return resultobj;
17399 fail:
17400 return NULL;
17401 }
17402
17403
17404 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17405 PyObject *obj;
17406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17407 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17408 return SWIG_Py_Void();
17409 }
17410
17411 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17412 return SWIG_Python_InitShadowInstance(args);
17413 }
17414
17415 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17416 PyObject *resultobj = 0;
17417 wxPCXHandler *result = 0 ;
17418
17419 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17420 {
17421 PyThreadState* __tstate = wxPyBeginAllowThreads();
17422 result = (wxPCXHandler *)new wxPCXHandler();
17423 wxPyEndAllowThreads(__tstate);
17424 if (PyErr_Occurred()) SWIG_fail;
17425 }
17426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17427 return resultobj;
17428 fail:
17429 return NULL;
17430 }
17431
17432
17433 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17434 PyObject *obj;
17435 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17436 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17437 return SWIG_Py_Void();
17438 }
17439
17440 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17441 return SWIG_Python_InitShadowInstance(args);
17442 }
17443
17444 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17445 PyObject *resultobj = 0;
17446 wxJPEGHandler *result = 0 ;
17447
17448 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17449 {
17450 PyThreadState* __tstate = wxPyBeginAllowThreads();
17451 result = (wxJPEGHandler *)new wxJPEGHandler();
17452 wxPyEndAllowThreads(__tstate);
17453 if (PyErr_Occurred()) SWIG_fail;
17454 }
17455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17456 return resultobj;
17457 fail:
17458 return NULL;
17459 }
17460
17461
17462 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17463 PyObject *obj;
17464 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17465 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17466 return SWIG_Py_Void();
17467 }
17468
17469 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17470 return SWIG_Python_InitShadowInstance(args);
17471 }
17472
17473 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17474 PyObject *resultobj = 0;
17475 wxPNMHandler *result = 0 ;
17476
17477 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17478 {
17479 PyThreadState* __tstate = wxPyBeginAllowThreads();
17480 result = (wxPNMHandler *)new wxPNMHandler();
17481 wxPyEndAllowThreads(__tstate);
17482 if (PyErr_Occurred()) SWIG_fail;
17483 }
17484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17485 return resultobj;
17486 fail:
17487 return NULL;
17488 }
17489
17490
17491 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17492 PyObject *obj;
17493 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17494 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17495 return SWIG_Py_Void();
17496 }
17497
17498 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17499 return SWIG_Python_InitShadowInstance(args);
17500 }
17501
17502 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17503 PyObject *resultobj = 0;
17504 wxXPMHandler *result = 0 ;
17505
17506 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17507 {
17508 PyThreadState* __tstate = wxPyBeginAllowThreads();
17509 result = (wxXPMHandler *)new wxXPMHandler();
17510 wxPyEndAllowThreads(__tstate);
17511 if (PyErr_Occurred()) SWIG_fail;
17512 }
17513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17514 return resultobj;
17515 fail:
17516 return NULL;
17517 }
17518
17519
17520 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17521 PyObject *obj;
17522 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17523 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17524 return SWIG_Py_Void();
17525 }
17526
17527 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17528 return SWIG_Python_InitShadowInstance(args);
17529 }
17530
17531 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17532 PyObject *resultobj = 0;
17533 wxTIFFHandler *result = 0 ;
17534
17535 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17536 {
17537 PyThreadState* __tstate = wxPyBeginAllowThreads();
17538 result = (wxTIFFHandler *)new wxTIFFHandler();
17539 wxPyEndAllowThreads(__tstate);
17540 if (PyErr_Occurred()) SWIG_fail;
17541 }
17542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17543 return resultobj;
17544 fail:
17545 return NULL;
17546 }
17547
17548
17549 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17550 PyObject *obj;
17551 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17552 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17553 return SWIG_Py_Void();
17554 }
17555
17556 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17557 return SWIG_Python_InitShadowInstance(args);
17558 }
17559
17560 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17561 PyObject *resultobj = 0;
17562 wxImage *arg1 = 0 ;
17563 wxImage *arg2 = 0 ;
17564 int arg3 = (int) 236 ;
17565 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17566 bool result;
17567 void *argp1 = 0 ;
17568 int res1 = 0 ;
17569 void *argp2 = 0 ;
17570 int res2 = 0 ;
17571 int val3 ;
17572 int ecode3 = 0 ;
17573 int val4 ;
17574 int ecode4 = 0 ;
17575 PyObject * obj0 = 0 ;
17576 PyObject * obj1 = 0 ;
17577 PyObject * obj2 = 0 ;
17578 PyObject * obj3 = 0 ;
17579 char * kwnames[] = {
17580 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17581 };
17582
17583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17584 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17585 if (!SWIG_IsOK(res1)) {
17586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17587 }
17588 if (!argp1) {
17589 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17590 }
17591 arg1 = reinterpret_cast< wxImage * >(argp1);
17592 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17593 if (!SWIG_IsOK(res2)) {
17594 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17595 }
17596 if (!argp2) {
17597 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17598 }
17599 arg2 = reinterpret_cast< wxImage * >(argp2);
17600 if (obj2) {
17601 ecode3 = SWIG_AsVal_int(obj2, &val3);
17602 if (!SWIG_IsOK(ecode3)) {
17603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17604 }
17605 arg3 = static_cast< int >(val3);
17606 }
17607 if (obj3) {
17608 ecode4 = SWIG_AsVal_int(obj3, &val4);
17609 if (!SWIG_IsOK(ecode4)) {
17610 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17611 }
17612 arg4 = static_cast< int >(val4);
17613 }
17614 {
17615 PyThreadState* __tstate = wxPyBeginAllowThreads();
17616 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17617 wxPyEndAllowThreads(__tstate);
17618 if (PyErr_Occurred()) SWIG_fail;
17619 }
17620 {
17621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17622 }
17623 return resultobj;
17624 fail:
17625 return NULL;
17626 }
17627
17628
17629 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17630 PyObject *obj;
17631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17632 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17633 return SWIG_Py_Void();
17634 }
17635
17636 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17637 PyObject *resultobj = 0;
17638 wxEvtHandler *result = 0 ;
17639
17640 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17641 {
17642 PyThreadState* __tstate = wxPyBeginAllowThreads();
17643 result = (wxEvtHandler *)new wxEvtHandler();
17644 wxPyEndAllowThreads(__tstate);
17645 if (PyErr_Occurred()) SWIG_fail;
17646 }
17647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17648 return resultobj;
17649 fail:
17650 return NULL;
17651 }
17652
17653
17654 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17655 PyObject *resultobj = 0;
17656 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17657 wxEvtHandler *result = 0 ;
17658 void *argp1 = 0 ;
17659 int res1 = 0 ;
17660 PyObject *swig_obj[1] ;
17661
17662 if (!args) SWIG_fail;
17663 swig_obj[0] = args;
17664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17665 if (!SWIG_IsOK(res1)) {
17666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17667 }
17668 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17669 {
17670 PyThreadState* __tstate = wxPyBeginAllowThreads();
17671 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17672 wxPyEndAllowThreads(__tstate);
17673 if (PyErr_Occurred()) SWIG_fail;
17674 }
17675 {
17676 resultobj = wxPyMake_wxObject(result, 0);
17677 }
17678 return resultobj;
17679 fail:
17680 return NULL;
17681 }
17682
17683
17684 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17685 PyObject *resultobj = 0;
17686 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17687 wxEvtHandler *result = 0 ;
17688 void *argp1 = 0 ;
17689 int res1 = 0 ;
17690 PyObject *swig_obj[1] ;
17691
17692 if (!args) SWIG_fail;
17693 swig_obj[0] = args;
17694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17695 if (!SWIG_IsOK(res1)) {
17696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17697 }
17698 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17699 {
17700 PyThreadState* __tstate = wxPyBeginAllowThreads();
17701 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17702 wxPyEndAllowThreads(__tstate);
17703 if (PyErr_Occurred()) SWIG_fail;
17704 }
17705 {
17706 resultobj = wxPyMake_wxObject(result, 0);
17707 }
17708 return resultobj;
17709 fail:
17710 return NULL;
17711 }
17712
17713
17714 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17715 PyObject *resultobj = 0;
17716 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17717 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17718 void *argp1 = 0 ;
17719 int res1 = 0 ;
17720 void *argp2 = 0 ;
17721 int res2 = 0 ;
17722 PyObject * obj0 = 0 ;
17723 PyObject * obj1 = 0 ;
17724 char * kwnames[] = {
17725 (char *) "self",(char *) "handler", NULL
17726 };
17727
17728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17730 if (!SWIG_IsOK(res1)) {
17731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17732 }
17733 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17734 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17735 if (!SWIG_IsOK(res2)) {
17736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17737 }
17738 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17739 {
17740 PyThreadState* __tstate = wxPyBeginAllowThreads();
17741 (arg1)->SetNextHandler(arg2);
17742 wxPyEndAllowThreads(__tstate);
17743 if (PyErr_Occurred()) SWIG_fail;
17744 }
17745 resultobj = SWIG_Py_Void();
17746 return resultobj;
17747 fail:
17748 return NULL;
17749 }
17750
17751
17752 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17753 PyObject *resultobj = 0;
17754 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17755 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17756 void *argp1 = 0 ;
17757 int res1 = 0 ;
17758 void *argp2 = 0 ;
17759 int res2 = 0 ;
17760 PyObject * obj0 = 0 ;
17761 PyObject * obj1 = 0 ;
17762 char * kwnames[] = {
17763 (char *) "self",(char *) "handler", NULL
17764 };
17765
17766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17768 if (!SWIG_IsOK(res1)) {
17769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17770 }
17771 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17772 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17773 if (!SWIG_IsOK(res2)) {
17774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17775 }
17776 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17777 {
17778 PyThreadState* __tstate = wxPyBeginAllowThreads();
17779 (arg1)->SetPreviousHandler(arg2);
17780 wxPyEndAllowThreads(__tstate);
17781 if (PyErr_Occurred()) SWIG_fail;
17782 }
17783 resultobj = SWIG_Py_Void();
17784 return resultobj;
17785 fail:
17786 return NULL;
17787 }
17788
17789
17790 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17791 PyObject *resultobj = 0;
17792 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17793 bool result;
17794 void *argp1 = 0 ;
17795 int res1 = 0 ;
17796 PyObject *swig_obj[1] ;
17797
17798 if (!args) SWIG_fail;
17799 swig_obj[0] = args;
17800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17801 if (!SWIG_IsOK(res1)) {
17802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17803 }
17804 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17805 {
17806 PyThreadState* __tstate = wxPyBeginAllowThreads();
17807 result = (bool)(arg1)->GetEvtHandlerEnabled();
17808 wxPyEndAllowThreads(__tstate);
17809 if (PyErr_Occurred()) SWIG_fail;
17810 }
17811 {
17812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17813 }
17814 return resultobj;
17815 fail:
17816 return NULL;
17817 }
17818
17819
17820 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17821 PyObject *resultobj = 0;
17822 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17823 bool arg2 ;
17824 void *argp1 = 0 ;
17825 int res1 = 0 ;
17826 bool val2 ;
17827 int ecode2 = 0 ;
17828 PyObject * obj0 = 0 ;
17829 PyObject * obj1 = 0 ;
17830 char * kwnames[] = {
17831 (char *) "self",(char *) "enabled", NULL
17832 };
17833
17834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17836 if (!SWIG_IsOK(res1)) {
17837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17838 }
17839 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17840 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17841 if (!SWIG_IsOK(ecode2)) {
17842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17843 }
17844 arg2 = static_cast< bool >(val2);
17845 {
17846 PyThreadState* __tstate = wxPyBeginAllowThreads();
17847 (arg1)->SetEvtHandlerEnabled(arg2);
17848 wxPyEndAllowThreads(__tstate);
17849 if (PyErr_Occurred()) SWIG_fail;
17850 }
17851 resultobj = SWIG_Py_Void();
17852 return resultobj;
17853 fail:
17854 return NULL;
17855 }
17856
17857
17858 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17859 PyObject *resultobj = 0;
17860 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17861 wxEvent *arg2 = 0 ;
17862 bool result;
17863 void *argp1 = 0 ;
17864 int res1 = 0 ;
17865 void *argp2 = 0 ;
17866 int res2 = 0 ;
17867 PyObject * obj0 = 0 ;
17868 PyObject * obj1 = 0 ;
17869 char * kwnames[] = {
17870 (char *) "self",(char *) "event", NULL
17871 };
17872
17873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17875 if (!SWIG_IsOK(res1)) {
17876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17877 }
17878 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17879 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17880 if (!SWIG_IsOK(res2)) {
17881 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17882 }
17883 if (!argp2) {
17884 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17885 }
17886 arg2 = reinterpret_cast< wxEvent * >(argp2);
17887 {
17888 PyThreadState* __tstate = wxPyBeginAllowThreads();
17889 result = (bool)(arg1)->ProcessEvent(*arg2);
17890 wxPyEndAllowThreads(__tstate);
17891 if (PyErr_Occurred()) SWIG_fail;
17892 }
17893 {
17894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17895 }
17896 return resultobj;
17897 fail:
17898 return NULL;
17899 }
17900
17901
17902 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17903 PyObject *resultobj = 0;
17904 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17905 wxEvent *arg2 = 0 ;
17906 void *argp1 = 0 ;
17907 int res1 = 0 ;
17908 void *argp2 = 0 ;
17909 int res2 = 0 ;
17910 PyObject * obj0 = 0 ;
17911 PyObject * obj1 = 0 ;
17912 char * kwnames[] = {
17913 (char *) "self",(char *) "event", NULL
17914 };
17915
17916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17918 if (!SWIG_IsOK(res1)) {
17919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17920 }
17921 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17922 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17923 if (!SWIG_IsOK(res2)) {
17924 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17925 }
17926 if (!argp2) {
17927 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17928 }
17929 arg2 = reinterpret_cast< wxEvent * >(argp2);
17930 {
17931 PyThreadState* __tstate = wxPyBeginAllowThreads();
17932 (arg1)->AddPendingEvent(*arg2);
17933 wxPyEndAllowThreads(__tstate);
17934 if (PyErr_Occurred()) SWIG_fail;
17935 }
17936 resultobj = SWIG_Py_Void();
17937 return resultobj;
17938 fail:
17939 return NULL;
17940 }
17941
17942
17943 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17944 PyObject *resultobj = 0;
17945 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17946 void *argp1 = 0 ;
17947 int res1 = 0 ;
17948 PyObject *swig_obj[1] ;
17949
17950 if (!args) SWIG_fail;
17951 swig_obj[0] = args;
17952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17953 if (!SWIG_IsOK(res1)) {
17954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17955 }
17956 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17957 {
17958 PyThreadState* __tstate = wxPyBeginAllowThreads();
17959 (arg1)->ProcessPendingEvents();
17960 wxPyEndAllowThreads(__tstate);
17961 if (PyErr_Occurred()) SWIG_fail;
17962 }
17963 resultobj = SWIG_Py_Void();
17964 return resultobj;
17965 fail:
17966 return NULL;
17967 }
17968
17969
17970 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17971 PyObject *resultobj = 0;
17972 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17973 int arg2 ;
17974 int arg3 ;
17975 int arg4 ;
17976 PyObject *arg5 = (PyObject *) 0 ;
17977 void *argp1 = 0 ;
17978 int res1 = 0 ;
17979 int val2 ;
17980 int ecode2 = 0 ;
17981 int val3 ;
17982 int ecode3 = 0 ;
17983 int val4 ;
17984 int ecode4 = 0 ;
17985 PyObject * obj0 = 0 ;
17986 PyObject * obj1 = 0 ;
17987 PyObject * obj2 = 0 ;
17988 PyObject * obj3 = 0 ;
17989 PyObject * obj4 = 0 ;
17990 char * kwnames[] = {
17991 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17992 };
17993
17994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17996 if (!SWIG_IsOK(res1)) {
17997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17998 }
17999 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18000 ecode2 = SWIG_AsVal_int(obj1, &val2);
18001 if (!SWIG_IsOK(ecode2)) {
18002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18003 }
18004 arg2 = static_cast< int >(val2);
18005 ecode3 = SWIG_AsVal_int(obj2, &val3);
18006 if (!SWIG_IsOK(ecode3)) {
18007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18008 }
18009 arg3 = static_cast< int >(val3);
18010 ecode4 = SWIG_AsVal_int(obj3, &val4);
18011 if (!SWIG_IsOK(ecode4)) {
18012 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18013 }
18014 arg4 = static_cast< int >(val4);
18015 arg5 = obj4;
18016 {
18017 PyThreadState* __tstate = wxPyBeginAllowThreads();
18018 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18019 wxPyEndAllowThreads(__tstate);
18020 if (PyErr_Occurred()) SWIG_fail;
18021 }
18022 resultobj = SWIG_Py_Void();
18023 return resultobj;
18024 fail:
18025 return NULL;
18026 }
18027
18028
18029 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18030 PyObject *resultobj = 0;
18031 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18032 int arg2 ;
18033 int arg3 = (int) -1 ;
18034 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18035 bool result;
18036 void *argp1 = 0 ;
18037 int res1 = 0 ;
18038 int val2 ;
18039 int ecode2 = 0 ;
18040 int val3 ;
18041 int ecode3 = 0 ;
18042 int val4 ;
18043 int ecode4 = 0 ;
18044 PyObject * obj0 = 0 ;
18045 PyObject * obj1 = 0 ;
18046 PyObject * obj2 = 0 ;
18047 PyObject * obj3 = 0 ;
18048 char * kwnames[] = {
18049 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18050 };
18051
18052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18054 if (!SWIG_IsOK(res1)) {
18055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18056 }
18057 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18058 ecode2 = SWIG_AsVal_int(obj1, &val2);
18059 if (!SWIG_IsOK(ecode2)) {
18060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18061 }
18062 arg2 = static_cast< int >(val2);
18063 if (obj2) {
18064 ecode3 = SWIG_AsVal_int(obj2, &val3);
18065 if (!SWIG_IsOK(ecode3)) {
18066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18067 }
18068 arg3 = static_cast< int >(val3);
18069 }
18070 if (obj3) {
18071 ecode4 = SWIG_AsVal_int(obj3, &val4);
18072 if (!SWIG_IsOK(ecode4)) {
18073 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18074 }
18075 arg4 = static_cast< wxEventType >(val4);
18076 }
18077 {
18078 PyThreadState* __tstate = wxPyBeginAllowThreads();
18079 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18080 wxPyEndAllowThreads(__tstate);
18081 if (PyErr_Occurred()) SWIG_fail;
18082 }
18083 {
18084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18085 }
18086 return resultobj;
18087 fail:
18088 return NULL;
18089 }
18090
18091
18092 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18093 PyObject *resultobj = 0;
18094 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18095 PyObject *arg2 = (PyObject *) 0 ;
18096 bool arg3 = (bool) true ;
18097 void *argp1 = 0 ;
18098 int res1 = 0 ;
18099 bool val3 ;
18100 int ecode3 = 0 ;
18101 PyObject * obj0 = 0 ;
18102 PyObject * obj1 = 0 ;
18103 PyObject * obj2 = 0 ;
18104 char * kwnames[] = {
18105 (char *) "self",(char *) "_self",(char *) "incref", NULL
18106 };
18107
18108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18110 if (!SWIG_IsOK(res1)) {
18111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18112 }
18113 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18114 arg2 = obj1;
18115 if (obj2) {
18116 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18117 if (!SWIG_IsOK(ecode3)) {
18118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18119 }
18120 arg3 = static_cast< bool >(val3);
18121 }
18122 {
18123 PyThreadState* __tstate = wxPyBeginAllowThreads();
18124 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18125 wxPyEndAllowThreads(__tstate);
18126 if (PyErr_Occurred()) SWIG_fail;
18127 }
18128 resultobj = SWIG_Py_Void();
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18136 PyObject *obj;
18137 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18138 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18139 return SWIG_Py_Void();
18140 }
18141
18142 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18143 return SWIG_Python_InitShadowInstance(args);
18144 }
18145
18146 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18147 PyObject *resultobj = 0;
18148 wxEventType result;
18149
18150 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18151 {
18152 PyThreadState* __tstate = wxPyBeginAllowThreads();
18153 result = (wxEventType)wxNewEventType();
18154 wxPyEndAllowThreads(__tstate);
18155 if (PyErr_Occurred()) SWIG_fail;
18156 }
18157 resultobj = SWIG_From_int(static_cast< int >(result));
18158 return resultobj;
18159 fail:
18160 return NULL;
18161 }
18162
18163
18164 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18165 PyObject *resultobj = 0;
18166 wxEvent *arg1 = (wxEvent *) 0 ;
18167 void *argp1 = 0 ;
18168 int res1 = 0 ;
18169 PyObject *swig_obj[1] ;
18170
18171 if (!args) SWIG_fail;
18172 swig_obj[0] = args;
18173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18174 if (!SWIG_IsOK(res1)) {
18175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18176 }
18177 arg1 = reinterpret_cast< wxEvent * >(argp1);
18178 {
18179 PyThreadState* __tstate = wxPyBeginAllowThreads();
18180 delete arg1;
18181
18182 wxPyEndAllowThreads(__tstate);
18183 if (PyErr_Occurred()) SWIG_fail;
18184 }
18185 resultobj = SWIG_Py_Void();
18186 return resultobj;
18187 fail:
18188 return NULL;
18189 }
18190
18191
18192 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18193 PyObject *resultobj = 0;
18194 wxEvent *arg1 = (wxEvent *) 0 ;
18195 wxEventType arg2 ;
18196 void *argp1 = 0 ;
18197 int res1 = 0 ;
18198 int val2 ;
18199 int ecode2 = 0 ;
18200 PyObject * obj0 = 0 ;
18201 PyObject * obj1 = 0 ;
18202 char * kwnames[] = {
18203 (char *) "self",(char *) "typ", NULL
18204 };
18205
18206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18208 if (!SWIG_IsOK(res1)) {
18209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18210 }
18211 arg1 = reinterpret_cast< wxEvent * >(argp1);
18212 ecode2 = SWIG_AsVal_int(obj1, &val2);
18213 if (!SWIG_IsOK(ecode2)) {
18214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18215 }
18216 arg2 = static_cast< wxEventType >(val2);
18217 {
18218 PyThreadState* __tstate = wxPyBeginAllowThreads();
18219 (arg1)->SetEventType(arg2);
18220 wxPyEndAllowThreads(__tstate);
18221 if (PyErr_Occurred()) SWIG_fail;
18222 }
18223 resultobj = SWIG_Py_Void();
18224 return resultobj;
18225 fail:
18226 return NULL;
18227 }
18228
18229
18230 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18231 PyObject *resultobj = 0;
18232 wxEvent *arg1 = (wxEvent *) 0 ;
18233 wxEventType result;
18234 void *argp1 = 0 ;
18235 int res1 = 0 ;
18236 PyObject *swig_obj[1] ;
18237
18238 if (!args) SWIG_fail;
18239 swig_obj[0] = args;
18240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18241 if (!SWIG_IsOK(res1)) {
18242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18243 }
18244 arg1 = reinterpret_cast< wxEvent * >(argp1);
18245 {
18246 PyThreadState* __tstate = wxPyBeginAllowThreads();
18247 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18248 wxPyEndAllowThreads(__tstate);
18249 if (PyErr_Occurred()) SWIG_fail;
18250 }
18251 resultobj = SWIG_From_int(static_cast< int >(result));
18252 return resultobj;
18253 fail:
18254 return NULL;
18255 }
18256
18257
18258 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18259 PyObject *resultobj = 0;
18260 wxEvent *arg1 = (wxEvent *) 0 ;
18261 wxObject *result = 0 ;
18262 void *argp1 = 0 ;
18263 int res1 = 0 ;
18264 PyObject *swig_obj[1] ;
18265
18266 if (!args) SWIG_fail;
18267 swig_obj[0] = args;
18268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18269 if (!SWIG_IsOK(res1)) {
18270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18271 }
18272 arg1 = reinterpret_cast< wxEvent * >(argp1);
18273 {
18274 PyThreadState* __tstate = wxPyBeginAllowThreads();
18275 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18276 wxPyEndAllowThreads(__tstate);
18277 if (PyErr_Occurred()) SWIG_fail;
18278 }
18279 {
18280 resultobj = wxPyMake_wxObject(result, (bool)0);
18281 }
18282 return resultobj;
18283 fail:
18284 return NULL;
18285 }
18286
18287
18288 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18289 PyObject *resultobj = 0;
18290 wxEvent *arg1 = (wxEvent *) 0 ;
18291 wxObject *arg2 = (wxObject *) 0 ;
18292 void *argp1 = 0 ;
18293 int res1 = 0 ;
18294 void *argp2 = 0 ;
18295 int res2 = 0 ;
18296 PyObject * obj0 = 0 ;
18297 PyObject * obj1 = 0 ;
18298 char * kwnames[] = {
18299 (char *) "self",(char *) "obj", NULL
18300 };
18301
18302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18304 if (!SWIG_IsOK(res1)) {
18305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18306 }
18307 arg1 = reinterpret_cast< wxEvent * >(argp1);
18308 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18309 if (!SWIG_IsOK(res2)) {
18310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18311 }
18312 arg2 = reinterpret_cast< wxObject * >(argp2);
18313 {
18314 PyThreadState* __tstate = wxPyBeginAllowThreads();
18315 (arg1)->SetEventObject(arg2);
18316 wxPyEndAllowThreads(__tstate);
18317 if (PyErr_Occurred()) SWIG_fail;
18318 }
18319 resultobj = SWIG_Py_Void();
18320 return resultobj;
18321 fail:
18322 return NULL;
18323 }
18324
18325
18326 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18327 PyObject *resultobj = 0;
18328 wxEvent *arg1 = (wxEvent *) 0 ;
18329 long result;
18330 void *argp1 = 0 ;
18331 int res1 = 0 ;
18332 PyObject *swig_obj[1] ;
18333
18334 if (!args) SWIG_fail;
18335 swig_obj[0] = args;
18336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18337 if (!SWIG_IsOK(res1)) {
18338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18339 }
18340 arg1 = reinterpret_cast< wxEvent * >(argp1);
18341 {
18342 PyThreadState* __tstate = wxPyBeginAllowThreads();
18343 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18344 wxPyEndAllowThreads(__tstate);
18345 if (PyErr_Occurred()) SWIG_fail;
18346 }
18347 resultobj = SWIG_From_long(static_cast< long >(result));
18348 return resultobj;
18349 fail:
18350 return NULL;
18351 }
18352
18353
18354 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18355 PyObject *resultobj = 0;
18356 wxEvent *arg1 = (wxEvent *) 0 ;
18357 long arg2 = (long) 0 ;
18358 void *argp1 = 0 ;
18359 int res1 = 0 ;
18360 long val2 ;
18361 int ecode2 = 0 ;
18362 PyObject * obj0 = 0 ;
18363 PyObject * obj1 = 0 ;
18364 char * kwnames[] = {
18365 (char *) "self",(char *) "ts", NULL
18366 };
18367
18368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18370 if (!SWIG_IsOK(res1)) {
18371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18372 }
18373 arg1 = reinterpret_cast< wxEvent * >(argp1);
18374 if (obj1) {
18375 ecode2 = SWIG_AsVal_long(obj1, &val2);
18376 if (!SWIG_IsOK(ecode2)) {
18377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18378 }
18379 arg2 = static_cast< long >(val2);
18380 }
18381 {
18382 PyThreadState* __tstate = wxPyBeginAllowThreads();
18383 (arg1)->SetTimestamp(arg2);
18384 wxPyEndAllowThreads(__tstate);
18385 if (PyErr_Occurred()) SWIG_fail;
18386 }
18387 resultobj = SWIG_Py_Void();
18388 return resultobj;
18389 fail:
18390 return NULL;
18391 }
18392
18393
18394 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18395 PyObject *resultobj = 0;
18396 wxEvent *arg1 = (wxEvent *) 0 ;
18397 int result;
18398 void *argp1 = 0 ;
18399 int res1 = 0 ;
18400 PyObject *swig_obj[1] ;
18401
18402 if (!args) SWIG_fail;
18403 swig_obj[0] = args;
18404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18405 if (!SWIG_IsOK(res1)) {
18406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18407 }
18408 arg1 = reinterpret_cast< wxEvent * >(argp1);
18409 {
18410 PyThreadState* __tstate = wxPyBeginAllowThreads();
18411 result = (int)((wxEvent const *)arg1)->GetId();
18412 wxPyEndAllowThreads(__tstate);
18413 if (PyErr_Occurred()) SWIG_fail;
18414 }
18415 resultobj = SWIG_From_int(static_cast< int >(result));
18416 return resultobj;
18417 fail:
18418 return NULL;
18419 }
18420
18421
18422 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18423 PyObject *resultobj = 0;
18424 wxEvent *arg1 = (wxEvent *) 0 ;
18425 int arg2 ;
18426 void *argp1 = 0 ;
18427 int res1 = 0 ;
18428 int val2 ;
18429 int ecode2 = 0 ;
18430 PyObject * obj0 = 0 ;
18431 PyObject * obj1 = 0 ;
18432 char * kwnames[] = {
18433 (char *) "self",(char *) "Id", NULL
18434 };
18435
18436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18438 if (!SWIG_IsOK(res1)) {
18439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18440 }
18441 arg1 = reinterpret_cast< wxEvent * >(argp1);
18442 ecode2 = SWIG_AsVal_int(obj1, &val2);
18443 if (!SWIG_IsOK(ecode2)) {
18444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18445 }
18446 arg2 = static_cast< int >(val2);
18447 {
18448 PyThreadState* __tstate = wxPyBeginAllowThreads();
18449 (arg1)->SetId(arg2);
18450 wxPyEndAllowThreads(__tstate);
18451 if (PyErr_Occurred()) SWIG_fail;
18452 }
18453 resultobj = SWIG_Py_Void();
18454 return resultobj;
18455 fail:
18456 return NULL;
18457 }
18458
18459
18460 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18461 PyObject *resultobj = 0;
18462 wxEvent *arg1 = (wxEvent *) 0 ;
18463 bool result;
18464 void *argp1 = 0 ;
18465 int res1 = 0 ;
18466 PyObject *swig_obj[1] ;
18467
18468 if (!args) SWIG_fail;
18469 swig_obj[0] = args;
18470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18471 if (!SWIG_IsOK(res1)) {
18472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18473 }
18474 arg1 = reinterpret_cast< wxEvent * >(argp1);
18475 {
18476 PyThreadState* __tstate = wxPyBeginAllowThreads();
18477 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18478 wxPyEndAllowThreads(__tstate);
18479 if (PyErr_Occurred()) SWIG_fail;
18480 }
18481 {
18482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18483 }
18484 return resultobj;
18485 fail:
18486 return NULL;
18487 }
18488
18489
18490 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18491 PyObject *resultobj = 0;
18492 wxEvent *arg1 = (wxEvent *) 0 ;
18493 bool arg2 = (bool) true ;
18494 void *argp1 = 0 ;
18495 int res1 = 0 ;
18496 bool val2 ;
18497 int ecode2 = 0 ;
18498 PyObject * obj0 = 0 ;
18499 PyObject * obj1 = 0 ;
18500 char * kwnames[] = {
18501 (char *) "self",(char *) "skip", NULL
18502 };
18503
18504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18506 if (!SWIG_IsOK(res1)) {
18507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18508 }
18509 arg1 = reinterpret_cast< wxEvent * >(argp1);
18510 if (obj1) {
18511 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18512 if (!SWIG_IsOK(ecode2)) {
18513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18514 }
18515 arg2 = static_cast< bool >(val2);
18516 }
18517 {
18518 PyThreadState* __tstate = wxPyBeginAllowThreads();
18519 (arg1)->Skip(arg2);
18520 wxPyEndAllowThreads(__tstate);
18521 if (PyErr_Occurred()) SWIG_fail;
18522 }
18523 resultobj = SWIG_Py_Void();
18524 return resultobj;
18525 fail:
18526 return NULL;
18527 }
18528
18529
18530 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18531 PyObject *resultobj = 0;
18532 wxEvent *arg1 = (wxEvent *) 0 ;
18533 bool result;
18534 void *argp1 = 0 ;
18535 int res1 = 0 ;
18536 PyObject *swig_obj[1] ;
18537
18538 if (!args) SWIG_fail;
18539 swig_obj[0] = args;
18540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18541 if (!SWIG_IsOK(res1)) {
18542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18543 }
18544 arg1 = reinterpret_cast< wxEvent * >(argp1);
18545 {
18546 PyThreadState* __tstate = wxPyBeginAllowThreads();
18547 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18548 wxPyEndAllowThreads(__tstate);
18549 if (PyErr_Occurred()) SWIG_fail;
18550 }
18551 {
18552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18553 }
18554 return resultobj;
18555 fail:
18556 return NULL;
18557 }
18558
18559
18560 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18561 PyObject *resultobj = 0;
18562 wxEvent *arg1 = (wxEvent *) 0 ;
18563 bool result;
18564 void *argp1 = 0 ;
18565 int res1 = 0 ;
18566 PyObject *swig_obj[1] ;
18567
18568 if (!args) SWIG_fail;
18569 swig_obj[0] = args;
18570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18571 if (!SWIG_IsOK(res1)) {
18572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18573 }
18574 arg1 = reinterpret_cast< wxEvent * >(argp1);
18575 {
18576 PyThreadState* __tstate = wxPyBeginAllowThreads();
18577 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18578 wxPyEndAllowThreads(__tstate);
18579 if (PyErr_Occurred()) SWIG_fail;
18580 }
18581 {
18582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18583 }
18584 return resultobj;
18585 fail:
18586 return NULL;
18587 }
18588
18589
18590 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18591 PyObject *resultobj = 0;
18592 wxEvent *arg1 = (wxEvent *) 0 ;
18593 int result;
18594 void *argp1 = 0 ;
18595 int res1 = 0 ;
18596 PyObject *swig_obj[1] ;
18597
18598 if (!args) SWIG_fail;
18599 swig_obj[0] = args;
18600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18601 if (!SWIG_IsOK(res1)) {
18602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18603 }
18604 arg1 = reinterpret_cast< wxEvent * >(argp1);
18605 {
18606 PyThreadState* __tstate = wxPyBeginAllowThreads();
18607 result = (int)(arg1)->StopPropagation();
18608 wxPyEndAllowThreads(__tstate);
18609 if (PyErr_Occurred()) SWIG_fail;
18610 }
18611 resultobj = SWIG_From_int(static_cast< int >(result));
18612 return resultobj;
18613 fail:
18614 return NULL;
18615 }
18616
18617
18618 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18619 PyObject *resultobj = 0;
18620 wxEvent *arg1 = (wxEvent *) 0 ;
18621 int arg2 ;
18622 void *argp1 = 0 ;
18623 int res1 = 0 ;
18624 int val2 ;
18625 int ecode2 = 0 ;
18626 PyObject * obj0 = 0 ;
18627 PyObject * obj1 = 0 ;
18628 char * kwnames[] = {
18629 (char *) "self",(char *) "propagationLevel", NULL
18630 };
18631
18632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18634 if (!SWIG_IsOK(res1)) {
18635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18636 }
18637 arg1 = reinterpret_cast< wxEvent * >(argp1);
18638 ecode2 = SWIG_AsVal_int(obj1, &val2);
18639 if (!SWIG_IsOK(ecode2)) {
18640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18641 }
18642 arg2 = static_cast< int >(val2);
18643 {
18644 PyThreadState* __tstate = wxPyBeginAllowThreads();
18645 (arg1)->ResumePropagation(arg2);
18646 wxPyEndAllowThreads(__tstate);
18647 if (PyErr_Occurred()) SWIG_fail;
18648 }
18649 resultobj = SWIG_Py_Void();
18650 return resultobj;
18651 fail:
18652 return NULL;
18653 }
18654
18655
18656 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18657 PyObject *resultobj = 0;
18658 wxEvent *arg1 = (wxEvent *) 0 ;
18659 wxEvent *result = 0 ;
18660 void *argp1 = 0 ;
18661 int res1 = 0 ;
18662 PyObject *swig_obj[1] ;
18663
18664 if (!args) SWIG_fail;
18665 swig_obj[0] = args;
18666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18667 if (!SWIG_IsOK(res1)) {
18668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18669 }
18670 arg1 = reinterpret_cast< wxEvent * >(argp1);
18671 {
18672 PyThreadState* __tstate = wxPyBeginAllowThreads();
18673 result = (wxEvent *)(arg1)->Clone();
18674 wxPyEndAllowThreads(__tstate);
18675 if (PyErr_Occurred()) SWIG_fail;
18676 }
18677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18678 return resultobj;
18679 fail:
18680 return NULL;
18681 }
18682
18683
18684 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18685 PyObject *obj;
18686 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18687 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18688 return SWIG_Py_Void();
18689 }
18690
18691 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18692 PyObject *resultobj = 0;
18693 wxEvent *arg1 = 0 ;
18694 wxPropagationDisabler *result = 0 ;
18695 void *argp1 = 0 ;
18696 int res1 = 0 ;
18697 PyObject * obj0 = 0 ;
18698 char * kwnames[] = {
18699 (char *) "event", NULL
18700 };
18701
18702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18703 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18704 if (!SWIG_IsOK(res1)) {
18705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18706 }
18707 if (!argp1) {
18708 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18709 }
18710 arg1 = reinterpret_cast< wxEvent * >(argp1);
18711 {
18712 PyThreadState* __tstate = wxPyBeginAllowThreads();
18713 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18714 wxPyEndAllowThreads(__tstate);
18715 if (PyErr_Occurred()) SWIG_fail;
18716 }
18717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18718 return resultobj;
18719 fail:
18720 return NULL;
18721 }
18722
18723
18724 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18725 PyObject *resultobj = 0;
18726 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18727 void *argp1 = 0 ;
18728 int res1 = 0 ;
18729 PyObject *swig_obj[1] ;
18730
18731 if (!args) SWIG_fail;
18732 swig_obj[0] = args;
18733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18734 if (!SWIG_IsOK(res1)) {
18735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18736 }
18737 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18738 {
18739 PyThreadState* __tstate = wxPyBeginAllowThreads();
18740 delete arg1;
18741
18742 wxPyEndAllowThreads(__tstate);
18743 if (PyErr_Occurred()) SWIG_fail;
18744 }
18745 resultobj = SWIG_Py_Void();
18746 return resultobj;
18747 fail:
18748 return NULL;
18749 }
18750
18751
18752 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18753 PyObject *obj;
18754 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18755 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18756 return SWIG_Py_Void();
18757 }
18758
18759 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18760 return SWIG_Python_InitShadowInstance(args);
18761 }
18762
18763 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18764 PyObject *resultobj = 0;
18765 wxEvent *arg1 = 0 ;
18766 wxPropagateOnce *result = 0 ;
18767 void *argp1 = 0 ;
18768 int res1 = 0 ;
18769 PyObject * obj0 = 0 ;
18770 char * kwnames[] = {
18771 (char *) "event", NULL
18772 };
18773
18774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18775 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18776 if (!SWIG_IsOK(res1)) {
18777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18778 }
18779 if (!argp1) {
18780 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18781 }
18782 arg1 = reinterpret_cast< wxEvent * >(argp1);
18783 {
18784 PyThreadState* __tstate = wxPyBeginAllowThreads();
18785 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18786 wxPyEndAllowThreads(__tstate);
18787 if (PyErr_Occurred()) SWIG_fail;
18788 }
18789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18790 return resultobj;
18791 fail:
18792 return NULL;
18793 }
18794
18795
18796 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18797 PyObject *resultobj = 0;
18798 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18799 void *argp1 = 0 ;
18800 int res1 = 0 ;
18801 PyObject *swig_obj[1] ;
18802
18803 if (!args) SWIG_fail;
18804 swig_obj[0] = args;
18805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18806 if (!SWIG_IsOK(res1)) {
18807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18808 }
18809 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18810 {
18811 PyThreadState* __tstate = wxPyBeginAllowThreads();
18812 delete arg1;
18813
18814 wxPyEndAllowThreads(__tstate);
18815 if (PyErr_Occurred()) SWIG_fail;
18816 }
18817 resultobj = SWIG_Py_Void();
18818 return resultobj;
18819 fail:
18820 return NULL;
18821 }
18822
18823
18824 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18825 PyObject *obj;
18826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18827 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18828 return SWIG_Py_Void();
18829 }
18830
18831 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18832 return SWIG_Python_InitShadowInstance(args);
18833 }
18834
18835 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18836 PyObject *resultobj = 0;
18837 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18838 int arg2 = (int) 0 ;
18839 wxCommandEvent *result = 0 ;
18840 int val1 ;
18841 int ecode1 = 0 ;
18842 int val2 ;
18843 int ecode2 = 0 ;
18844 PyObject * obj0 = 0 ;
18845 PyObject * obj1 = 0 ;
18846 char * kwnames[] = {
18847 (char *) "commandType",(char *) "winid", NULL
18848 };
18849
18850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18851 if (obj0) {
18852 ecode1 = SWIG_AsVal_int(obj0, &val1);
18853 if (!SWIG_IsOK(ecode1)) {
18854 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18855 }
18856 arg1 = static_cast< wxEventType >(val1);
18857 }
18858 if (obj1) {
18859 ecode2 = SWIG_AsVal_int(obj1, &val2);
18860 if (!SWIG_IsOK(ecode2)) {
18861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18862 }
18863 arg2 = static_cast< int >(val2);
18864 }
18865 {
18866 PyThreadState* __tstate = wxPyBeginAllowThreads();
18867 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18868 wxPyEndAllowThreads(__tstate);
18869 if (PyErr_Occurred()) SWIG_fail;
18870 }
18871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18872 return resultobj;
18873 fail:
18874 return NULL;
18875 }
18876
18877
18878 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18879 PyObject *resultobj = 0;
18880 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18881 int result;
18882 void *argp1 = 0 ;
18883 int res1 = 0 ;
18884 PyObject *swig_obj[1] ;
18885
18886 if (!args) SWIG_fail;
18887 swig_obj[0] = args;
18888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18889 if (!SWIG_IsOK(res1)) {
18890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18891 }
18892 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18893 {
18894 PyThreadState* __tstate = wxPyBeginAllowThreads();
18895 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18896 wxPyEndAllowThreads(__tstate);
18897 if (PyErr_Occurred()) SWIG_fail;
18898 }
18899 resultobj = SWIG_From_int(static_cast< int >(result));
18900 return resultobj;
18901 fail:
18902 return NULL;
18903 }
18904
18905
18906 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18907 PyObject *resultobj = 0;
18908 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18909 wxString *arg2 = 0 ;
18910 void *argp1 = 0 ;
18911 int res1 = 0 ;
18912 bool temp2 = false ;
18913 PyObject * obj0 = 0 ;
18914 PyObject * obj1 = 0 ;
18915 char * kwnames[] = {
18916 (char *) "self",(char *) "s", NULL
18917 };
18918
18919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18921 if (!SWIG_IsOK(res1)) {
18922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18923 }
18924 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18925 {
18926 arg2 = wxString_in_helper(obj1);
18927 if (arg2 == NULL) SWIG_fail;
18928 temp2 = true;
18929 }
18930 {
18931 PyThreadState* __tstate = wxPyBeginAllowThreads();
18932 (arg1)->SetString((wxString const &)*arg2);
18933 wxPyEndAllowThreads(__tstate);
18934 if (PyErr_Occurred()) SWIG_fail;
18935 }
18936 resultobj = SWIG_Py_Void();
18937 {
18938 if (temp2)
18939 delete arg2;
18940 }
18941 return resultobj;
18942 fail:
18943 {
18944 if (temp2)
18945 delete arg2;
18946 }
18947 return NULL;
18948 }
18949
18950
18951 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18952 PyObject *resultobj = 0;
18953 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18954 wxString result;
18955 void *argp1 = 0 ;
18956 int res1 = 0 ;
18957 PyObject *swig_obj[1] ;
18958
18959 if (!args) SWIG_fail;
18960 swig_obj[0] = args;
18961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18962 if (!SWIG_IsOK(res1)) {
18963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18964 }
18965 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18966 {
18967 PyThreadState* __tstate = wxPyBeginAllowThreads();
18968 result = ((wxCommandEvent const *)arg1)->GetString();
18969 wxPyEndAllowThreads(__tstate);
18970 if (PyErr_Occurred()) SWIG_fail;
18971 }
18972 {
18973 #if wxUSE_UNICODE
18974 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18975 #else
18976 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18977 #endif
18978 }
18979 return resultobj;
18980 fail:
18981 return NULL;
18982 }
18983
18984
18985 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18986 PyObject *resultobj = 0;
18987 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18988 bool result;
18989 void *argp1 = 0 ;
18990 int res1 = 0 ;
18991 PyObject *swig_obj[1] ;
18992
18993 if (!args) SWIG_fail;
18994 swig_obj[0] = args;
18995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18996 if (!SWIG_IsOK(res1)) {
18997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18998 }
18999 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19000 {
19001 PyThreadState* __tstate = wxPyBeginAllowThreads();
19002 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19003 wxPyEndAllowThreads(__tstate);
19004 if (PyErr_Occurred()) SWIG_fail;
19005 }
19006 {
19007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19008 }
19009 return resultobj;
19010 fail:
19011 return NULL;
19012 }
19013
19014
19015 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19016 PyObject *resultobj = 0;
19017 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19018 bool result;
19019 void *argp1 = 0 ;
19020 int res1 = 0 ;
19021 PyObject *swig_obj[1] ;
19022
19023 if (!args) SWIG_fail;
19024 swig_obj[0] = args;
19025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19026 if (!SWIG_IsOK(res1)) {
19027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19028 }
19029 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19030 {
19031 PyThreadState* __tstate = wxPyBeginAllowThreads();
19032 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19033 wxPyEndAllowThreads(__tstate);
19034 if (PyErr_Occurred()) SWIG_fail;
19035 }
19036 {
19037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19038 }
19039 return resultobj;
19040 fail:
19041 return NULL;
19042 }
19043
19044
19045 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19046 PyObject *resultobj = 0;
19047 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19048 long arg2 ;
19049 void *argp1 = 0 ;
19050 int res1 = 0 ;
19051 long val2 ;
19052 int ecode2 = 0 ;
19053 PyObject * obj0 = 0 ;
19054 PyObject * obj1 = 0 ;
19055 char * kwnames[] = {
19056 (char *) "self",(char *) "extraLong", NULL
19057 };
19058
19059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19061 if (!SWIG_IsOK(res1)) {
19062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19063 }
19064 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19065 ecode2 = SWIG_AsVal_long(obj1, &val2);
19066 if (!SWIG_IsOK(ecode2)) {
19067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19068 }
19069 arg2 = static_cast< long >(val2);
19070 {
19071 PyThreadState* __tstate = wxPyBeginAllowThreads();
19072 (arg1)->SetExtraLong(arg2);
19073 wxPyEndAllowThreads(__tstate);
19074 if (PyErr_Occurred()) SWIG_fail;
19075 }
19076 resultobj = SWIG_Py_Void();
19077 return resultobj;
19078 fail:
19079 return NULL;
19080 }
19081
19082
19083 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19084 PyObject *resultobj = 0;
19085 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19086 long result;
19087 void *argp1 = 0 ;
19088 int res1 = 0 ;
19089 PyObject *swig_obj[1] ;
19090
19091 if (!args) SWIG_fail;
19092 swig_obj[0] = args;
19093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19094 if (!SWIG_IsOK(res1)) {
19095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19096 }
19097 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19098 {
19099 PyThreadState* __tstate = wxPyBeginAllowThreads();
19100 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19101 wxPyEndAllowThreads(__tstate);
19102 if (PyErr_Occurred()) SWIG_fail;
19103 }
19104 resultobj = SWIG_From_long(static_cast< long >(result));
19105 return resultobj;
19106 fail:
19107 return NULL;
19108 }
19109
19110
19111 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19112 PyObject *resultobj = 0;
19113 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19114 int arg2 ;
19115 void *argp1 = 0 ;
19116 int res1 = 0 ;
19117 int val2 ;
19118 int ecode2 = 0 ;
19119 PyObject * obj0 = 0 ;
19120 PyObject * obj1 = 0 ;
19121 char * kwnames[] = {
19122 (char *) "self",(char *) "i", NULL
19123 };
19124
19125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19127 if (!SWIG_IsOK(res1)) {
19128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19129 }
19130 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19131 ecode2 = SWIG_AsVal_int(obj1, &val2);
19132 if (!SWIG_IsOK(ecode2)) {
19133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19134 }
19135 arg2 = static_cast< int >(val2);
19136 {
19137 PyThreadState* __tstate = wxPyBeginAllowThreads();
19138 (arg1)->SetInt(arg2);
19139 wxPyEndAllowThreads(__tstate);
19140 if (PyErr_Occurred()) SWIG_fail;
19141 }
19142 resultobj = SWIG_Py_Void();
19143 return resultobj;
19144 fail:
19145 return NULL;
19146 }
19147
19148
19149 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19150 PyObject *resultobj = 0;
19151 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19152 int result;
19153 void *argp1 = 0 ;
19154 int res1 = 0 ;
19155 PyObject *swig_obj[1] ;
19156
19157 if (!args) SWIG_fail;
19158 swig_obj[0] = args;
19159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19160 if (!SWIG_IsOK(res1)) {
19161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19162 }
19163 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19164 {
19165 PyThreadState* __tstate = wxPyBeginAllowThreads();
19166 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19167 wxPyEndAllowThreads(__tstate);
19168 if (PyErr_Occurred()) SWIG_fail;
19169 }
19170 resultobj = SWIG_From_int(static_cast< int >(result));
19171 return resultobj;
19172 fail:
19173 return NULL;
19174 }
19175
19176
19177 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19178 PyObject *resultobj = 0;
19179 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19180 PyObject *result = 0 ;
19181 void *argp1 = 0 ;
19182 int res1 = 0 ;
19183 PyObject *swig_obj[1] ;
19184
19185 if (!args) SWIG_fail;
19186 swig_obj[0] = args;
19187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19188 if (!SWIG_IsOK(res1)) {
19189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19190 }
19191 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19192 {
19193 PyThreadState* __tstate = wxPyBeginAllowThreads();
19194 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19195 wxPyEndAllowThreads(__tstate);
19196 if (PyErr_Occurred()) SWIG_fail;
19197 }
19198 resultobj = result;
19199 return resultobj;
19200 fail:
19201 return NULL;
19202 }
19203
19204
19205 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19206 PyObject *resultobj = 0;
19207 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19208 PyObject *arg2 = (PyObject *) 0 ;
19209 void *argp1 = 0 ;
19210 int res1 = 0 ;
19211 PyObject * obj0 = 0 ;
19212 PyObject * obj1 = 0 ;
19213 char * kwnames[] = {
19214 (char *) "self",(char *) "clientData", NULL
19215 };
19216
19217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19219 if (!SWIG_IsOK(res1)) {
19220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19221 }
19222 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19223 arg2 = obj1;
19224 {
19225 PyThreadState* __tstate = wxPyBeginAllowThreads();
19226 wxCommandEvent_SetClientData(arg1,arg2);
19227 wxPyEndAllowThreads(__tstate);
19228 if (PyErr_Occurred()) SWIG_fail;
19229 }
19230 resultobj = SWIG_Py_Void();
19231 return resultobj;
19232 fail:
19233 return NULL;
19234 }
19235
19236
19237 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19238 PyObject *resultobj = 0;
19239 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19240 wxEvent *result = 0 ;
19241 void *argp1 = 0 ;
19242 int res1 = 0 ;
19243 PyObject *swig_obj[1] ;
19244
19245 if (!args) SWIG_fail;
19246 swig_obj[0] = args;
19247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19248 if (!SWIG_IsOK(res1)) {
19249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19250 }
19251 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19252 {
19253 PyThreadState* __tstate = wxPyBeginAllowThreads();
19254 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19255 wxPyEndAllowThreads(__tstate);
19256 if (PyErr_Occurred()) SWIG_fail;
19257 }
19258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19259 return resultobj;
19260 fail:
19261 return NULL;
19262 }
19263
19264
19265 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19266 PyObject *obj;
19267 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19268 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19269 return SWIG_Py_Void();
19270 }
19271
19272 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19273 return SWIG_Python_InitShadowInstance(args);
19274 }
19275
19276 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19277 PyObject *resultobj = 0;
19278 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19279 int arg2 = (int) 0 ;
19280 wxNotifyEvent *result = 0 ;
19281 int val1 ;
19282 int ecode1 = 0 ;
19283 int val2 ;
19284 int ecode2 = 0 ;
19285 PyObject * obj0 = 0 ;
19286 PyObject * obj1 = 0 ;
19287 char * kwnames[] = {
19288 (char *) "commandType",(char *) "winid", NULL
19289 };
19290
19291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19292 if (obj0) {
19293 ecode1 = SWIG_AsVal_int(obj0, &val1);
19294 if (!SWIG_IsOK(ecode1)) {
19295 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19296 }
19297 arg1 = static_cast< wxEventType >(val1);
19298 }
19299 if (obj1) {
19300 ecode2 = SWIG_AsVal_int(obj1, &val2);
19301 if (!SWIG_IsOK(ecode2)) {
19302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19303 }
19304 arg2 = static_cast< int >(val2);
19305 }
19306 {
19307 PyThreadState* __tstate = wxPyBeginAllowThreads();
19308 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19309 wxPyEndAllowThreads(__tstate);
19310 if (PyErr_Occurred()) SWIG_fail;
19311 }
19312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19313 return resultobj;
19314 fail:
19315 return NULL;
19316 }
19317
19318
19319 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19320 PyObject *resultobj = 0;
19321 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19322 void *argp1 = 0 ;
19323 int res1 = 0 ;
19324 PyObject *swig_obj[1] ;
19325
19326 if (!args) SWIG_fail;
19327 swig_obj[0] = args;
19328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19329 if (!SWIG_IsOK(res1)) {
19330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19331 }
19332 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19333 {
19334 PyThreadState* __tstate = wxPyBeginAllowThreads();
19335 (arg1)->Veto();
19336 wxPyEndAllowThreads(__tstate);
19337 if (PyErr_Occurred()) SWIG_fail;
19338 }
19339 resultobj = SWIG_Py_Void();
19340 return resultobj;
19341 fail:
19342 return NULL;
19343 }
19344
19345
19346 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19347 PyObject *resultobj = 0;
19348 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19349 void *argp1 = 0 ;
19350 int res1 = 0 ;
19351 PyObject *swig_obj[1] ;
19352
19353 if (!args) SWIG_fail;
19354 swig_obj[0] = args;
19355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19356 if (!SWIG_IsOK(res1)) {
19357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19358 }
19359 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19360 {
19361 PyThreadState* __tstate = wxPyBeginAllowThreads();
19362 (arg1)->Allow();
19363 wxPyEndAllowThreads(__tstate);
19364 if (PyErr_Occurred()) SWIG_fail;
19365 }
19366 resultobj = SWIG_Py_Void();
19367 return resultobj;
19368 fail:
19369 return NULL;
19370 }
19371
19372
19373 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19374 PyObject *resultobj = 0;
19375 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19376 bool result;
19377 void *argp1 = 0 ;
19378 int res1 = 0 ;
19379 PyObject *swig_obj[1] ;
19380
19381 if (!args) SWIG_fail;
19382 swig_obj[0] = args;
19383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19384 if (!SWIG_IsOK(res1)) {
19385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19386 }
19387 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19388 {
19389 PyThreadState* __tstate = wxPyBeginAllowThreads();
19390 result = (bool)(arg1)->IsAllowed();
19391 wxPyEndAllowThreads(__tstate);
19392 if (PyErr_Occurred()) SWIG_fail;
19393 }
19394 {
19395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19396 }
19397 return resultobj;
19398 fail:
19399 return NULL;
19400 }
19401
19402
19403 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19404 PyObject *obj;
19405 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19406 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19407 return SWIG_Py_Void();
19408 }
19409
19410 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19411 return SWIG_Python_InitShadowInstance(args);
19412 }
19413
19414 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19415 PyObject *resultobj = 0;
19416 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19417 int arg2 = (int) 0 ;
19418 int arg3 = (int) 0 ;
19419 int arg4 = (int) 0 ;
19420 wxScrollEvent *result = 0 ;
19421 int val1 ;
19422 int ecode1 = 0 ;
19423 int val2 ;
19424 int ecode2 = 0 ;
19425 int val3 ;
19426 int ecode3 = 0 ;
19427 int val4 ;
19428 int ecode4 = 0 ;
19429 PyObject * obj0 = 0 ;
19430 PyObject * obj1 = 0 ;
19431 PyObject * obj2 = 0 ;
19432 PyObject * obj3 = 0 ;
19433 char * kwnames[] = {
19434 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19435 };
19436
19437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19438 if (obj0) {
19439 ecode1 = SWIG_AsVal_int(obj0, &val1);
19440 if (!SWIG_IsOK(ecode1)) {
19441 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19442 }
19443 arg1 = static_cast< wxEventType >(val1);
19444 }
19445 if (obj1) {
19446 ecode2 = SWIG_AsVal_int(obj1, &val2);
19447 if (!SWIG_IsOK(ecode2)) {
19448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19449 }
19450 arg2 = static_cast< int >(val2);
19451 }
19452 if (obj2) {
19453 ecode3 = SWIG_AsVal_int(obj2, &val3);
19454 if (!SWIG_IsOK(ecode3)) {
19455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19456 }
19457 arg3 = static_cast< int >(val3);
19458 }
19459 if (obj3) {
19460 ecode4 = SWIG_AsVal_int(obj3, &val4);
19461 if (!SWIG_IsOK(ecode4)) {
19462 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19463 }
19464 arg4 = static_cast< int >(val4);
19465 }
19466 {
19467 PyThreadState* __tstate = wxPyBeginAllowThreads();
19468 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19469 wxPyEndAllowThreads(__tstate);
19470 if (PyErr_Occurred()) SWIG_fail;
19471 }
19472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19473 return resultobj;
19474 fail:
19475 return NULL;
19476 }
19477
19478
19479 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19480 PyObject *resultobj = 0;
19481 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19482 int result;
19483 void *argp1 = 0 ;
19484 int res1 = 0 ;
19485 PyObject *swig_obj[1] ;
19486
19487 if (!args) SWIG_fail;
19488 swig_obj[0] = args;
19489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19490 if (!SWIG_IsOK(res1)) {
19491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19492 }
19493 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19494 {
19495 PyThreadState* __tstate = wxPyBeginAllowThreads();
19496 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19497 wxPyEndAllowThreads(__tstate);
19498 if (PyErr_Occurred()) SWIG_fail;
19499 }
19500 resultobj = SWIG_From_int(static_cast< int >(result));
19501 return resultobj;
19502 fail:
19503 return NULL;
19504 }
19505
19506
19507 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19508 PyObject *resultobj = 0;
19509 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19510 int result;
19511 void *argp1 = 0 ;
19512 int res1 = 0 ;
19513 PyObject *swig_obj[1] ;
19514
19515 if (!args) SWIG_fail;
19516 swig_obj[0] = args;
19517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19518 if (!SWIG_IsOK(res1)) {
19519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19520 }
19521 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19522 {
19523 PyThreadState* __tstate = wxPyBeginAllowThreads();
19524 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19525 wxPyEndAllowThreads(__tstate);
19526 if (PyErr_Occurred()) SWIG_fail;
19527 }
19528 resultobj = SWIG_From_int(static_cast< int >(result));
19529 return resultobj;
19530 fail:
19531 return NULL;
19532 }
19533
19534
19535 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19536 PyObject *resultobj = 0;
19537 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19538 int arg2 ;
19539 void *argp1 = 0 ;
19540 int res1 = 0 ;
19541 int val2 ;
19542 int ecode2 = 0 ;
19543 PyObject * obj0 = 0 ;
19544 PyObject * obj1 = 0 ;
19545 char * kwnames[] = {
19546 (char *) "self",(char *) "orient", NULL
19547 };
19548
19549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19551 if (!SWIG_IsOK(res1)) {
19552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19553 }
19554 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19555 ecode2 = SWIG_AsVal_int(obj1, &val2);
19556 if (!SWIG_IsOK(ecode2)) {
19557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19558 }
19559 arg2 = static_cast< int >(val2);
19560 {
19561 PyThreadState* __tstate = wxPyBeginAllowThreads();
19562 (arg1)->SetOrientation(arg2);
19563 wxPyEndAllowThreads(__tstate);
19564 if (PyErr_Occurred()) SWIG_fail;
19565 }
19566 resultobj = SWIG_Py_Void();
19567 return resultobj;
19568 fail:
19569 return NULL;
19570 }
19571
19572
19573 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19574 PyObject *resultobj = 0;
19575 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19576 int arg2 ;
19577 void *argp1 = 0 ;
19578 int res1 = 0 ;
19579 int val2 ;
19580 int ecode2 = 0 ;
19581 PyObject * obj0 = 0 ;
19582 PyObject * obj1 = 0 ;
19583 char * kwnames[] = {
19584 (char *) "self",(char *) "pos", NULL
19585 };
19586
19587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19589 if (!SWIG_IsOK(res1)) {
19590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19591 }
19592 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19593 ecode2 = SWIG_AsVal_int(obj1, &val2);
19594 if (!SWIG_IsOK(ecode2)) {
19595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19596 }
19597 arg2 = static_cast< int >(val2);
19598 {
19599 PyThreadState* __tstate = wxPyBeginAllowThreads();
19600 (arg1)->SetPosition(arg2);
19601 wxPyEndAllowThreads(__tstate);
19602 if (PyErr_Occurred()) SWIG_fail;
19603 }
19604 resultobj = SWIG_Py_Void();
19605 return resultobj;
19606 fail:
19607 return NULL;
19608 }
19609
19610
19611 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19612 PyObject *obj;
19613 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19614 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19615 return SWIG_Py_Void();
19616 }
19617
19618 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19619 return SWIG_Python_InitShadowInstance(args);
19620 }
19621
19622 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19623 PyObject *resultobj = 0;
19624 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19625 int arg2 = (int) 0 ;
19626 int arg3 = (int) 0 ;
19627 wxScrollWinEvent *result = 0 ;
19628 int val1 ;
19629 int ecode1 = 0 ;
19630 int val2 ;
19631 int ecode2 = 0 ;
19632 int val3 ;
19633 int ecode3 = 0 ;
19634 PyObject * obj0 = 0 ;
19635 PyObject * obj1 = 0 ;
19636 PyObject * obj2 = 0 ;
19637 char * kwnames[] = {
19638 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19639 };
19640
19641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19642 if (obj0) {
19643 ecode1 = SWIG_AsVal_int(obj0, &val1);
19644 if (!SWIG_IsOK(ecode1)) {
19645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19646 }
19647 arg1 = static_cast< wxEventType >(val1);
19648 }
19649 if (obj1) {
19650 ecode2 = SWIG_AsVal_int(obj1, &val2);
19651 if (!SWIG_IsOK(ecode2)) {
19652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19653 }
19654 arg2 = static_cast< int >(val2);
19655 }
19656 if (obj2) {
19657 ecode3 = SWIG_AsVal_int(obj2, &val3);
19658 if (!SWIG_IsOK(ecode3)) {
19659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19660 }
19661 arg3 = static_cast< int >(val3);
19662 }
19663 {
19664 PyThreadState* __tstate = wxPyBeginAllowThreads();
19665 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19666 wxPyEndAllowThreads(__tstate);
19667 if (PyErr_Occurred()) SWIG_fail;
19668 }
19669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19670 return resultobj;
19671 fail:
19672 return NULL;
19673 }
19674
19675
19676 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19677 PyObject *resultobj = 0;
19678 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19679 int result;
19680 void *argp1 = 0 ;
19681 int res1 = 0 ;
19682 PyObject *swig_obj[1] ;
19683
19684 if (!args) SWIG_fail;
19685 swig_obj[0] = args;
19686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19687 if (!SWIG_IsOK(res1)) {
19688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19689 }
19690 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19691 {
19692 PyThreadState* __tstate = wxPyBeginAllowThreads();
19693 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19694 wxPyEndAllowThreads(__tstate);
19695 if (PyErr_Occurred()) SWIG_fail;
19696 }
19697 resultobj = SWIG_From_int(static_cast< int >(result));
19698 return resultobj;
19699 fail:
19700 return NULL;
19701 }
19702
19703
19704 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19705 PyObject *resultobj = 0;
19706 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19707 int result;
19708 void *argp1 = 0 ;
19709 int res1 = 0 ;
19710 PyObject *swig_obj[1] ;
19711
19712 if (!args) SWIG_fail;
19713 swig_obj[0] = args;
19714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19715 if (!SWIG_IsOK(res1)) {
19716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19717 }
19718 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19719 {
19720 PyThreadState* __tstate = wxPyBeginAllowThreads();
19721 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19722 wxPyEndAllowThreads(__tstate);
19723 if (PyErr_Occurred()) SWIG_fail;
19724 }
19725 resultobj = SWIG_From_int(static_cast< int >(result));
19726 return resultobj;
19727 fail:
19728 return NULL;
19729 }
19730
19731
19732 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19733 PyObject *resultobj = 0;
19734 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19735 int arg2 ;
19736 void *argp1 = 0 ;
19737 int res1 = 0 ;
19738 int val2 ;
19739 int ecode2 = 0 ;
19740 PyObject * obj0 = 0 ;
19741 PyObject * obj1 = 0 ;
19742 char * kwnames[] = {
19743 (char *) "self",(char *) "orient", NULL
19744 };
19745
19746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19748 if (!SWIG_IsOK(res1)) {
19749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19750 }
19751 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19752 ecode2 = SWIG_AsVal_int(obj1, &val2);
19753 if (!SWIG_IsOK(ecode2)) {
19754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19755 }
19756 arg2 = static_cast< int >(val2);
19757 {
19758 PyThreadState* __tstate = wxPyBeginAllowThreads();
19759 (arg1)->SetOrientation(arg2);
19760 wxPyEndAllowThreads(__tstate);
19761 if (PyErr_Occurred()) SWIG_fail;
19762 }
19763 resultobj = SWIG_Py_Void();
19764 return resultobj;
19765 fail:
19766 return NULL;
19767 }
19768
19769
19770 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19771 PyObject *resultobj = 0;
19772 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19773 int arg2 ;
19774 void *argp1 = 0 ;
19775 int res1 = 0 ;
19776 int val2 ;
19777 int ecode2 = 0 ;
19778 PyObject * obj0 = 0 ;
19779 PyObject * obj1 = 0 ;
19780 char * kwnames[] = {
19781 (char *) "self",(char *) "pos", NULL
19782 };
19783
19784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19786 if (!SWIG_IsOK(res1)) {
19787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19788 }
19789 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19790 ecode2 = SWIG_AsVal_int(obj1, &val2);
19791 if (!SWIG_IsOK(ecode2)) {
19792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19793 }
19794 arg2 = static_cast< int >(val2);
19795 {
19796 PyThreadState* __tstate = wxPyBeginAllowThreads();
19797 (arg1)->SetPosition(arg2);
19798 wxPyEndAllowThreads(__tstate);
19799 if (PyErr_Occurred()) SWIG_fail;
19800 }
19801 resultobj = SWIG_Py_Void();
19802 return resultobj;
19803 fail:
19804 return NULL;
19805 }
19806
19807
19808 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19809 PyObject *obj;
19810 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19811 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19812 return SWIG_Py_Void();
19813 }
19814
19815 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19816 return SWIG_Python_InitShadowInstance(args);
19817 }
19818
19819 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19820 PyObject *resultobj = 0;
19821 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19822 wxMouseEvent *result = 0 ;
19823 int val1 ;
19824 int ecode1 = 0 ;
19825 PyObject * obj0 = 0 ;
19826 char * kwnames[] = {
19827 (char *) "mouseType", NULL
19828 };
19829
19830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19831 if (obj0) {
19832 ecode1 = SWIG_AsVal_int(obj0, &val1);
19833 if (!SWIG_IsOK(ecode1)) {
19834 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19835 }
19836 arg1 = static_cast< wxEventType >(val1);
19837 }
19838 {
19839 PyThreadState* __tstate = wxPyBeginAllowThreads();
19840 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19841 wxPyEndAllowThreads(__tstate);
19842 if (PyErr_Occurred()) SWIG_fail;
19843 }
19844 {
19845 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19846 }
19847 return resultobj;
19848 fail:
19849 return NULL;
19850 }
19851
19852
19853 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19854 PyObject *resultobj = 0;
19855 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19856 bool result;
19857 void *argp1 = 0 ;
19858 int res1 = 0 ;
19859 PyObject *swig_obj[1] ;
19860
19861 if (!args) SWIG_fail;
19862 swig_obj[0] = args;
19863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19864 if (!SWIG_IsOK(res1)) {
19865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19866 }
19867 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19868 {
19869 PyThreadState* __tstate = wxPyBeginAllowThreads();
19870 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19871 wxPyEndAllowThreads(__tstate);
19872 if (PyErr_Occurred()) SWIG_fail;
19873 }
19874 {
19875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19876 }
19877 return resultobj;
19878 fail:
19879 return NULL;
19880 }
19881
19882
19883 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19884 PyObject *resultobj = 0;
19885 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19886 int arg2 = (int) wxMOUSE_BTN_ANY ;
19887 bool result;
19888 void *argp1 = 0 ;
19889 int res1 = 0 ;
19890 int val2 ;
19891 int ecode2 = 0 ;
19892 PyObject * obj0 = 0 ;
19893 PyObject * obj1 = 0 ;
19894 char * kwnames[] = {
19895 (char *) "self",(char *) "but", NULL
19896 };
19897
19898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19900 if (!SWIG_IsOK(res1)) {
19901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19902 }
19903 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19904 if (obj1) {
19905 ecode2 = SWIG_AsVal_int(obj1, &val2);
19906 if (!SWIG_IsOK(ecode2)) {
19907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19908 }
19909 arg2 = static_cast< int >(val2);
19910 }
19911 {
19912 PyThreadState* __tstate = wxPyBeginAllowThreads();
19913 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19914 wxPyEndAllowThreads(__tstate);
19915 if (PyErr_Occurred()) SWIG_fail;
19916 }
19917 {
19918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19919 }
19920 return resultobj;
19921 fail:
19922 return NULL;
19923 }
19924
19925
19926 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19927 PyObject *resultobj = 0;
19928 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19929 int arg2 = (int) wxMOUSE_BTN_ANY ;
19930 bool result;
19931 void *argp1 = 0 ;
19932 int res1 = 0 ;
19933 int val2 ;
19934 int ecode2 = 0 ;
19935 PyObject * obj0 = 0 ;
19936 PyObject * obj1 = 0 ;
19937 char * kwnames[] = {
19938 (char *) "self",(char *) "but", NULL
19939 };
19940
19941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19943 if (!SWIG_IsOK(res1)) {
19944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19945 }
19946 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19947 if (obj1) {
19948 ecode2 = SWIG_AsVal_int(obj1, &val2);
19949 if (!SWIG_IsOK(ecode2)) {
19950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19951 }
19952 arg2 = static_cast< int >(val2);
19953 }
19954 {
19955 PyThreadState* __tstate = wxPyBeginAllowThreads();
19956 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19957 wxPyEndAllowThreads(__tstate);
19958 if (PyErr_Occurred()) SWIG_fail;
19959 }
19960 {
19961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19962 }
19963 return resultobj;
19964 fail:
19965 return NULL;
19966 }
19967
19968
19969 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19970 PyObject *resultobj = 0;
19971 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19972 int arg2 = (int) wxMOUSE_BTN_ANY ;
19973 bool result;
19974 void *argp1 = 0 ;
19975 int res1 = 0 ;
19976 int val2 ;
19977 int ecode2 = 0 ;
19978 PyObject * obj0 = 0 ;
19979 PyObject * obj1 = 0 ;
19980 char * kwnames[] = {
19981 (char *) "self",(char *) "but", NULL
19982 };
19983
19984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19986 if (!SWIG_IsOK(res1)) {
19987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19988 }
19989 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19990 if (obj1) {
19991 ecode2 = SWIG_AsVal_int(obj1, &val2);
19992 if (!SWIG_IsOK(ecode2)) {
19993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19994 }
19995 arg2 = static_cast< int >(val2);
19996 }
19997 {
19998 PyThreadState* __tstate = wxPyBeginAllowThreads();
19999 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20000 wxPyEndAllowThreads(__tstate);
20001 if (PyErr_Occurred()) SWIG_fail;
20002 }
20003 {
20004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20005 }
20006 return resultobj;
20007 fail:
20008 return NULL;
20009 }
20010
20011
20012 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20013 PyObject *resultobj = 0;
20014 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20015 int arg2 ;
20016 bool result;
20017 void *argp1 = 0 ;
20018 int res1 = 0 ;
20019 int val2 ;
20020 int ecode2 = 0 ;
20021 PyObject * obj0 = 0 ;
20022 PyObject * obj1 = 0 ;
20023 char * kwnames[] = {
20024 (char *) "self",(char *) "button", NULL
20025 };
20026
20027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20029 if (!SWIG_IsOK(res1)) {
20030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20031 }
20032 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20033 ecode2 = SWIG_AsVal_int(obj1, &val2);
20034 if (!SWIG_IsOK(ecode2)) {
20035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20036 }
20037 arg2 = static_cast< int >(val2);
20038 {
20039 PyThreadState* __tstate = wxPyBeginAllowThreads();
20040 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20041 wxPyEndAllowThreads(__tstate);
20042 if (PyErr_Occurred()) SWIG_fail;
20043 }
20044 {
20045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20046 }
20047 return resultobj;
20048 fail:
20049 return NULL;
20050 }
20051
20052
20053 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20054 PyObject *resultobj = 0;
20055 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20056 int arg2 ;
20057 bool result;
20058 void *argp1 = 0 ;
20059 int res1 = 0 ;
20060 int val2 ;
20061 int ecode2 = 0 ;
20062 PyObject * obj0 = 0 ;
20063 PyObject * obj1 = 0 ;
20064 char * kwnames[] = {
20065 (char *) "self",(char *) "but", NULL
20066 };
20067
20068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20070 if (!SWIG_IsOK(res1)) {
20071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20072 }
20073 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20074 ecode2 = SWIG_AsVal_int(obj1, &val2);
20075 if (!SWIG_IsOK(ecode2)) {
20076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20077 }
20078 arg2 = static_cast< int >(val2);
20079 {
20080 PyThreadState* __tstate = wxPyBeginAllowThreads();
20081 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20082 wxPyEndAllowThreads(__tstate);
20083 if (PyErr_Occurred()) SWIG_fail;
20084 }
20085 {
20086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20087 }
20088 return resultobj;
20089 fail:
20090 return NULL;
20091 }
20092
20093
20094 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20095 PyObject *resultobj = 0;
20096 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20097 int result;
20098 void *argp1 = 0 ;
20099 int res1 = 0 ;
20100 PyObject *swig_obj[1] ;
20101
20102 if (!args) SWIG_fail;
20103 swig_obj[0] = args;
20104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20105 if (!SWIG_IsOK(res1)) {
20106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20107 }
20108 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20109 {
20110 PyThreadState* __tstate = wxPyBeginAllowThreads();
20111 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20112 wxPyEndAllowThreads(__tstate);
20113 if (PyErr_Occurred()) SWIG_fail;
20114 }
20115 resultobj = SWIG_From_int(static_cast< int >(result));
20116 return resultobj;
20117 fail:
20118 return NULL;
20119 }
20120
20121
20122 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20123 PyObject *resultobj = 0;
20124 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20125 bool result;
20126 void *argp1 = 0 ;
20127 int res1 = 0 ;
20128 PyObject *swig_obj[1] ;
20129
20130 if (!args) SWIG_fail;
20131 swig_obj[0] = args;
20132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20133 if (!SWIG_IsOK(res1)) {
20134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20135 }
20136 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20137 {
20138 PyThreadState* __tstate = wxPyBeginAllowThreads();
20139 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20140 wxPyEndAllowThreads(__tstate);
20141 if (PyErr_Occurred()) SWIG_fail;
20142 }
20143 {
20144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20145 }
20146 return resultobj;
20147 fail:
20148 return NULL;
20149 }
20150
20151
20152 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20153 PyObject *resultobj = 0;
20154 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20155 bool result;
20156 void *argp1 = 0 ;
20157 int res1 = 0 ;
20158 PyObject *swig_obj[1] ;
20159
20160 if (!args) SWIG_fail;
20161 swig_obj[0] = args;
20162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20163 if (!SWIG_IsOK(res1)) {
20164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20165 }
20166 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20167 {
20168 PyThreadState* __tstate = wxPyBeginAllowThreads();
20169 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20170 wxPyEndAllowThreads(__tstate);
20171 if (PyErr_Occurred()) SWIG_fail;
20172 }
20173 {
20174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20175 }
20176 return resultobj;
20177 fail:
20178 return NULL;
20179 }
20180
20181
20182 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20183 PyObject *resultobj = 0;
20184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20185 bool result;
20186 void *argp1 = 0 ;
20187 int res1 = 0 ;
20188 PyObject *swig_obj[1] ;
20189
20190 if (!args) SWIG_fail;
20191 swig_obj[0] = args;
20192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20193 if (!SWIG_IsOK(res1)) {
20194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20195 }
20196 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20197 {
20198 PyThreadState* __tstate = wxPyBeginAllowThreads();
20199 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20200 wxPyEndAllowThreads(__tstate);
20201 if (PyErr_Occurred()) SWIG_fail;
20202 }
20203 {
20204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20205 }
20206 return resultobj;
20207 fail:
20208 return NULL;
20209 }
20210
20211
20212 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20213 PyObject *resultobj = 0;
20214 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20215 bool result;
20216 void *argp1 = 0 ;
20217 int res1 = 0 ;
20218 PyObject *swig_obj[1] ;
20219
20220 if (!args) SWIG_fail;
20221 swig_obj[0] = args;
20222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20223 if (!SWIG_IsOK(res1)) {
20224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20225 }
20226 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20227 {
20228 PyThreadState* __tstate = wxPyBeginAllowThreads();
20229 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20230 wxPyEndAllowThreads(__tstate);
20231 if (PyErr_Occurred()) SWIG_fail;
20232 }
20233 {
20234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20235 }
20236 return resultobj;
20237 fail:
20238 return NULL;
20239 }
20240
20241
20242 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20243 PyObject *resultobj = 0;
20244 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20245 bool result;
20246 void *argp1 = 0 ;
20247 int res1 = 0 ;
20248 PyObject *swig_obj[1] ;
20249
20250 if (!args) SWIG_fail;
20251 swig_obj[0] = args;
20252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20253 if (!SWIG_IsOK(res1)) {
20254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20255 }
20256 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20257 {
20258 PyThreadState* __tstate = wxPyBeginAllowThreads();
20259 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20260 wxPyEndAllowThreads(__tstate);
20261 if (PyErr_Occurred()) SWIG_fail;
20262 }
20263 {
20264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20265 }
20266 return resultobj;
20267 fail:
20268 return NULL;
20269 }
20270
20271
20272 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20273 PyObject *resultobj = 0;
20274 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20275 bool result;
20276 void *argp1 = 0 ;
20277 int res1 = 0 ;
20278 PyObject *swig_obj[1] ;
20279
20280 if (!args) SWIG_fail;
20281 swig_obj[0] = args;
20282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20283 if (!SWIG_IsOK(res1)) {
20284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20285 }
20286 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20287 {
20288 PyThreadState* __tstate = wxPyBeginAllowThreads();
20289 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20290 wxPyEndAllowThreads(__tstate);
20291 if (PyErr_Occurred()) SWIG_fail;
20292 }
20293 {
20294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20295 }
20296 return resultobj;
20297 fail:
20298 return NULL;
20299 }
20300
20301
20302 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20303 PyObject *resultobj = 0;
20304 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20305 bool result;
20306 void *argp1 = 0 ;
20307 int res1 = 0 ;
20308 PyObject *swig_obj[1] ;
20309
20310 if (!args) SWIG_fail;
20311 swig_obj[0] = args;
20312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20313 if (!SWIG_IsOK(res1)) {
20314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20315 }
20316 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20317 {
20318 PyThreadState* __tstate = wxPyBeginAllowThreads();
20319 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20320 wxPyEndAllowThreads(__tstate);
20321 if (PyErr_Occurred()) SWIG_fail;
20322 }
20323 {
20324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20325 }
20326 return resultobj;
20327 fail:
20328 return NULL;
20329 }
20330
20331
20332 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20333 PyObject *resultobj = 0;
20334 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20335 bool result;
20336 void *argp1 = 0 ;
20337 int res1 = 0 ;
20338 PyObject *swig_obj[1] ;
20339
20340 if (!args) SWIG_fail;
20341 swig_obj[0] = args;
20342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20343 if (!SWIG_IsOK(res1)) {
20344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20345 }
20346 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20347 {
20348 PyThreadState* __tstate = wxPyBeginAllowThreads();
20349 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20350 wxPyEndAllowThreads(__tstate);
20351 if (PyErr_Occurred()) SWIG_fail;
20352 }
20353 {
20354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20355 }
20356 return resultobj;
20357 fail:
20358 return NULL;
20359 }
20360
20361
20362 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20363 PyObject *resultobj = 0;
20364 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20365 bool result;
20366 void *argp1 = 0 ;
20367 int res1 = 0 ;
20368 PyObject *swig_obj[1] ;
20369
20370 if (!args) SWIG_fail;
20371 swig_obj[0] = args;
20372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20373 if (!SWIG_IsOK(res1)) {
20374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20375 }
20376 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20377 {
20378 PyThreadState* __tstate = wxPyBeginAllowThreads();
20379 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20380 wxPyEndAllowThreads(__tstate);
20381 if (PyErr_Occurred()) SWIG_fail;
20382 }
20383 {
20384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20385 }
20386 return resultobj;
20387 fail:
20388 return NULL;
20389 }
20390
20391
20392 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20393 PyObject *resultobj = 0;
20394 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20395 bool result;
20396 void *argp1 = 0 ;
20397 int res1 = 0 ;
20398 PyObject *swig_obj[1] ;
20399
20400 if (!args) SWIG_fail;
20401 swig_obj[0] = args;
20402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20403 if (!SWIG_IsOK(res1)) {
20404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20405 }
20406 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20407 {
20408 PyThreadState* __tstate = wxPyBeginAllowThreads();
20409 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20410 wxPyEndAllowThreads(__tstate);
20411 if (PyErr_Occurred()) SWIG_fail;
20412 }
20413 {
20414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20415 }
20416 return resultobj;
20417 fail:
20418 return NULL;
20419 }
20420
20421
20422 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20423 PyObject *resultobj = 0;
20424 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20425 bool result;
20426 void *argp1 = 0 ;
20427 int res1 = 0 ;
20428 PyObject *swig_obj[1] ;
20429
20430 if (!args) SWIG_fail;
20431 swig_obj[0] = args;
20432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20433 if (!SWIG_IsOK(res1)) {
20434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20435 }
20436 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20437 {
20438 PyThreadState* __tstate = wxPyBeginAllowThreads();
20439 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20440 wxPyEndAllowThreads(__tstate);
20441 if (PyErr_Occurred()) SWIG_fail;
20442 }
20443 {
20444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20445 }
20446 return resultobj;
20447 fail:
20448 return NULL;
20449 }
20450
20451
20452 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20453 PyObject *resultobj = 0;
20454 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20455 bool result;
20456 void *argp1 = 0 ;
20457 int res1 = 0 ;
20458 PyObject *swig_obj[1] ;
20459
20460 if (!args) SWIG_fail;
20461 swig_obj[0] = args;
20462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20463 if (!SWIG_IsOK(res1)) {
20464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20465 }
20466 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20467 {
20468 PyThreadState* __tstate = wxPyBeginAllowThreads();
20469 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20470 wxPyEndAllowThreads(__tstate);
20471 if (PyErr_Occurred()) SWIG_fail;
20472 }
20473 {
20474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20475 }
20476 return resultobj;
20477 fail:
20478 return NULL;
20479 }
20480
20481
20482 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20483 PyObject *resultobj = 0;
20484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20485 bool result;
20486 void *argp1 = 0 ;
20487 int res1 = 0 ;
20488 PyObject *swig_obj[1] ;
20489
20490 if (!args) SWIG_fail;
20491 swig_obj[0] = args;
20492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20493 if (!SWIG_IsOK(res1)) {
20494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20495 }
20496 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20497 {
20498 PyThreadState* __tstate = wxPyBeginAllowThreads();
20499 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20500 wxPyEndAllowThreads(__tstate);
20501 if (PyErr_Occurred()) SWIG_fail;
20502 }
20503 {
20504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20505 }
20506 return resultobj;
20507 fail:
20508 return NULL;
20509 }
20510
20511
20512 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20513 PyObject *resultobj = 0;
20514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20515 bool result;
20516 void *argp1 = 0 ;
20517 int res1 = 0 ;
20518 PyObject *swig_obj[1] ;
20519
20520 if (!args) SWIG_fail;
20521 swig_obj[0] = args;
20522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20523 if (!SWIG_IsOK(res1)) {
20524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20525 }
20526 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20527 {
20528 PyThreadState* __tstate = wxPyBeginAllowThreads();
20529 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20530 wxPyEndAllowThreads(__tstate);
20531 if (PyErr_Occurred()) SWIG_fail;
20532 }
20533 {
20534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20535 }
20536 return resultobj;
20537 fail:
20538 return NULL;
20539 }
20540
20541
20542 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20543 PyObject *resultobj = 0;
20544 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20545 bool result;
20546 void *argp1 = 0 ;
20547 int res1 = 0 ;
20548 PyObject *swig_obj[1] ;
20549
20550 if (!args) SWIG_fail;
20551 swig_obj[0] = args;
20552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20553 if (!SWIG_IsOK(res1)) {
20554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20555 }
20556 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20557 {
20558 PyThreadState* __tstate = wxPyBeginAllowThreads();
20559 result = (bool)(arg1)->LeftIsDown();
20560 wxPyEndAllowThreads(__tstate);
20561 if (PyErr_Occurred()) SWIG_fail;
20562 }
20563 {
20564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20565 }
20566 return resultobj;
20567 fail:
20568 return NULL;
20569 }
20570
20571
20572 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20573 PyObject *resultobj = 0;
20574 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20575 bool result;
20576 void *argp1 = 0 ;
20577 int res1 = 0 ;
20578 PyObject *swig_obj[1] ;
20579
20580 if (!args) SWIG_fail;
20581 swig_obj[0] = args;
20582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20583 if (!SWIG_IsOK(res1)) {
20584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20585 }
20586 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20587 {
20588 PyThreadState* __tstate = wxPyBeginAllowThreads();
20589 result = (bool)(arg1)->MiddleIsDown();
20590 wxPyEndAllowThreads(__tstate);
20591 if (PyErr_Occurred()) SWIG_fail;
20592 }
20593 {
20594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20595 }
20596 return resultobj;
20597 fail:
20598 return NULL;
20599 }
20600
20601
20602 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20603 PyObject *resultobj = 0;
20604 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20605 bool result;
20606 void *argp1 = 0 ;
20607 int res1 = 0 ;
20608 PyObject *swig_obj[1] ;
20609
20610 if (!args) SWIG_fail;
20611 swig_obj[0] = args;
20612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20613 if (!SWIG_IsOK(res1)) {
20614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20615 }
20616 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20617 {
20618 PyThreadState* __tstate = wxPyBeginAllowThreads();
20619 result = (bool)(arg1)->RightIsDown();
20620 wxPyEndAllowThreads(__tstate);
20621 if (PyErr_Occurred()) SWIG_fail;
20622 }
20623 {
20624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20625 }
20626 return resultobj;
20627 fail:
20628 return NULL;
20629 }
20630
20631
20632 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20633 PyObject *resultobj = 0;
20634 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20635 bool result;
20636 void *argp1 = 0 ;
20637 int res1 = 0 ;
20638 PyObject *swig_obj[1] ;
20639
20640 if (!args) SWIG_fail;
20641 swig_obj[0] = args;
20642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20643 if (!SWIG_IsOK(res1)) {
20644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20645 }
20646 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20647 {
20648 PyThreadState* __tstate = wxPyBeginAllowThreads();
20649 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20650 wxPyEndAllowThreads(__tstate);
20651 if (PyErr_Occurred()) SWIG_fail;
20652 }
20653 {
20654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20655 }
20656 return resultobj;
20657 fail:
20658 return NULL;
20659 }
20660
20661
20662 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20663 PyObject *resultobj = 0;
20664 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20665 bool result;
20666 void *argp1 = 0 ;
20667 int res1 = 0 ;
20668 PyObject *swig_obj[1] ;
20669
20670 if (!args) SWIG_fail;
20671 swig_obj[0] = args;
20672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20673 if (!SWIG_IsOK(res1)) {
20674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20675 }
20676 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20677 {
20678 PyThreadState* __tstate = wxPyBeginAllowThreads();
20679 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20680 wxPyEndAllowThreads(__tstate);
20681 if (PyErr_Occurred()) SWIG_fail;
20682 }
20683 {
20684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20685 }
20686 return resultobj;
20687 fail:
20688 return NULL;
20689 }
20690
20691
20692 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20693 PyObject *resultobj = 0;
20694 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20695 bool result;
20696 void *argp1 = 0 ;
20697 int res1 = 0 ;
20698 PyObject *swig_obj[1] ;
20699
20700 if (!args) SWIG_fail;
20701 swig_obj[0] = args;
20702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20703 if (!SWIG_IsOK(res1)) {
20704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20705 }
20706 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20707 {
20708 PyThreadState* __tstate = wxPyBeginAllowThreads();
20709 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20710 wxPyEndAllowThreads(__tstate);
20711 if (PyErr_Occurred()) SWIG_fail;
20712 }
20713 {
20714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20715 }
20716 return resultobj;
20717 fail:
20718 return NULL;
20719 }
20720
20721
20722 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20723 PyObject *resultobj = 0;
20724 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20725 bool result;
20726 void *argp1 = 0 ;
20727 int res1 = 0 ;
20728 PyObject *swig_obj[1] ;
20729
20730 if (!args) SWIG_fail;
20731 swig_obj[0] = args;
20732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20733 if (!SWIG_IsOK(res1)) {
20734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20735 }
20736 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20737 {
20738 PyThreadState* __tstate = wxPyBeginAllowThreads();
20739 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20740 wxPyEndAllowThreads(__tstate);
20741 if (PyErr_Occurred()) SWIG_fail;
20742 }
20743 {
20744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20745 }
20746 return resultobj;
20747 fail:
20748 return NULL;
20749 }
20750
20751
20752 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20753 PyObject *resultobj = 0;
20754 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20755 wxPoint result;
20756 void *argp1 = 0 ;
20757 int res1 = 0 ;
20758 PyObject *swig_obj[1] ;
20759
20760 if (!args) SWIG_fail;
20761 swig_obj[0] = args;
20762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20763 if (!SWIG_IsOK(res1)) {
20764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20765 }
20766 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20767 {
20768 PyThreadState* __tstate = wxPyBeginAllowThreads();
20769 result = (arg1)->GetPosition();
20770 wxPyEndAllowThreads(__tstate);
20771 if (PyErr_Occurred()) SWIG_fail;
20772 }
20773 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20774 return resultobj;
20775 fail:
20776 return NULL;
20777 }
20778
20779
20780 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20781 PyObject *resultobj = 0;
20782 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20783 long *arg2 = (long *) 0 ;
20784 long *arg3 = (long *) 0 ;
20785 void *argp1 = 0 ;
20786 int res1 = 0 ;
20787 long temp2 ;
20788 int res2 = SWIG_TMPOBJ ;
20789 long temp3 ;
20790 int res3 = SWIG_TMPOBJ ;
20791 PyObject *swig_obj[1] ;
20792
20793 arg2 = &temp2;
20794 arg3 = &temp3;
20795 if (!args) SWIG_fail;
20796 swig_obj[0] = args;
20797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20798 if (!SWIG_IsOK(res1)) {
20799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20800 }
20801 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20802 {
20803 PyThreadState* __tstate = wxPyBeginAllowThreads();
20804 (arg1)->GetPosition(arg2,arg3);
20805 wxPyEndAllowThreads(__tstate);
20806 if (PyErr_Occurred()) SWIG_fail;
20807 }
20808 resultobj = SWIG_Py_Void();
20809 if (SWIG_IsTmpObj(res2)) {
20810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20811 } else {
20812 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20814 }
20815 if (SWIG_IsTmpObj(res3)) {
20816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20817 } else {
20818 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20820 }
20821 return resultobj;
20822 fail:
20823 return NULL;
20824 }
20825
20826
20827 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20828 PyObject *resultobj = 0;
20829 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20830 wxDC *arg2 = 0 ;
20831 wxPoint result;
20832 void *argp1 = 0 ;
20833 int res1 = 0 ;
20834 void *argp2 = 0 ;
20835 int res2 = 0 ;
20836 PyObject * obj0 = 0 ;
20837 PyObject * obj1 = 0 ;
20838 char * kwnames[] = {
20839 (char *) "self",(char *) "dc", NULL
20840 };
20841
20842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20844 if (!SWIG_IsOK(res1)) {
20845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20846 }
20847 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20848 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20849 if (!SWIG_IsOK(res2)) {
20850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20851 }
20852 if (!argp2) {
20853 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20854 }
20855 arg2 = reinterpret_cast< wxDC * >(argp2);
20856 {
20857 PyThreadState* __tstate = wxPyBeginAllowThreads();
20858 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20859 wxPyEndAllowThreads(__tstate);
20860 if (PyErr_Occurred()) SWIG_fail;
20861 }
20862 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20863 return resultobj;
20864 fail:
20865 return NULL;
20866 }
20867
20868
20869 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20870 PyObject *resultobj = 0;
20871 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20872 int result;
20873 void *argp1 = 0 ;
20874 int res1 = 0 ;
20875 PyObject *swig_obj[1] ;
20876
20877 if (!args) SWIG_fail;
20878 swig_obj[0] = args;
20879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20880 if (!SWIG_IsOK(res1)) {
20881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20882 }
20883 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20884 {
20885 PyThreadState* __tstate = wxPyBeginAllowThreads();
20886 result = (int)((wxMouseEvent const *)arg1)->GetX();
20887 wxPyEndAllowThreads(__tstate);
20888 if (PyErr_Occurred()) SWIG_fail;
20889 }
20890 resultobj = SWIG_From_int(static_cast< int >(result));
20891 return resultobj;
20892 fail:
20893 return NULL;
20894 }
20895
20896
20897 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20898 PyObject *resultobj = 0;
20899 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20900 int result;
20901 void *argp1 = 0 ;
20902 int res1 = 0 ;
20903 PyObject *swig_obj[1] ;
20904
20905 if (!args) SWIG_fail;
20906 swig_obj[0] = args;
20907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20908 if (!SWIG_IsOK(res1)) {
20909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20910 }
20911 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20912 {
20913 PyThreadState* __tstate = wxPyBeginAllowThreads();
20914 result = (int)((wxMouseEvent const *)arg1)->GetY();
20915 wxPyEndAllowThreads(__tstate);
20916 if (PyErr_Occurred()) SWIG_fail;
20917 }
20918 resultobj = SWIG_From_int(static_cast< int >(result));
20919 return resultobj;
20920 fail:
20921 return NULL;
20922 }
20923
20924
20925 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20926 PyObject *resultobj = 0;
20927 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20928 int result;
20929 void *argp1 = 0 ;
20930 int res1 = 0 ;
20931 PyObject *swig_obj[1] ;
20932
20933 if (!args) SWIG_fail;
20934 swig_obj[0] = args;
20935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20936 if (!SWIG_IsOK(res1)) {
20937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20938 }
20939 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20940 {
20941 PyThreadState* __tstate = wxPyBeginAllowThreads();
20942 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20943 wxPyEndAllowThreads(__tstate);
20944 if (PyErr_Occurred()) SWIG_fail;
20945 }
20946 resultobj = SWIG_From_int(static_cast< int >(result));
20947 return resultobj;
20948 fail:
20949 return NULL;
20950 }
20951
20952
20953 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20954 PyObject *resultobj = 0;
20955 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20956 int result;
20957 void *argp1 = 0 ;
20958 int res1 = 0 ;
20959 PyObject *swig_obj[1] ;
20960
20961 if (!args) SWIG_fail;
20962 swig_obj[0] = args;
20963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20964 if (!SWIG_IsOK(res1)) {
20965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20966 }
20967 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20968 {
20969 PyThreadState* __tstate = wxPyBeginAllowThreads();
20970 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20971 wxPyEndAllowThreads(__tstate);
20972 if (PyErr_Occurred()) SWIG_fail;
20973 }
20974 resultobj = SWIG_From_int(static_cast< int >(result));
20975 return resultobj;
20976 fail:
20977 return NULL;
20978 }
20979
20980
20981 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20982 PyObject *resultobj = 0;
20983 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20984 int result;
20985 void *argp1 = 0 ;
20986 int res1 = 0 ;
20987 PyObject *swig_obj[1] ;
20988
20989 if (!args) SWIG_fail;
20990 swig_obj[0] = args;
20991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20992 if (!SWIG_IsOK(res1)) {
20993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20994 }
20995 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20996 {
20997 PyThreadState* __tstate = wxPyBeginAllowThreads();
20998 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20999 wxPyEndAllowThreads(__tstate);
21000 if (PyErr_Occurred()) SWIG_fail;
21001 }
21002 resultobj = SWIG_From_int(static_cast< int >(result));
21003 return resultobj;
21004 fail:
21005 return NULL;
21006 }
21007
21008
21009 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21010 PyObject *resultobj = 0;
21011 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21012 bool result;
21013 void *argp1 = 0 ;
21014 int res1 = 0 ;
21015 PyObject *swig_obj[1] ;
21016
21017 if (!args) SWIG_fail;
21018 swig_obj[0] = args;
21019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21020 if (!SWIG_IsOK(res1)) {
21021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21022 }
21023 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21024 {
21025 PyThreadState* __tstate = wxPyBeginAllowThreads();
21026 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21027 wxPyEndAllowThreads(__tstate);
21028 if (PyErr_Occurred()) SWIG_fail;
21029 }
21030 {
21031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21032 }
21033 return resultobj;
21034 fail:
21035 return NULL;
21036 }
21037
21038
21039 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21040 PyObject *resultobj = 0;
21041 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21042 int arg2 ;
21043 void *argp1 = 0 ;
21044 int res1 = 0 ;
21045 int val2 ;
21046 int ecode2 = 0 ;
21047 PyObject *swig_obj[2] ;
21048
21049 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21051 if (!SWIG_IsOK(res1)) {
21052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21053 }
21054 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21055 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21056 if (!SWIG_IsOK(ecode2)) {
21057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21058 }
21059 arg2 = static_cast< int >(val2);
21060 if (arg1) (arg1)->m_x = arg2;
21061
21062 resultobj = SWIG_Py_Void();
21063 return resultobj;
21064 fail:
21065 return NULL;
21066 }
21067
21068
21069 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21070 PyObject *resultobj = 0;
21071 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21072 int result;
21073 void *argp1 = 0 ;
21074 int res1 = 0 ;
21075 PyObject *swig_obj[1] ;
21076
21077 if (!args) SWIG_fail;
21078 swig_obj[0] = args;
21079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21080 if (!SWIG_IsOK(res1)) {
21081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21082 }
21083 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21084 result = (int) ((arg1)->m_x);
21085 resultobj = SWIG_From_int(static_cast< int >(result));
21086 return resultobj;
21087 fail:
21088 return NULL;
21089 }
21090
21091
21092 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21093 PyObject *resultobj = 0;
21094 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21095 int arg2 ;
21096 void *argp1 = 0 ;
21097 int res1 = 0 ;
21098 int val2 ;
21099 int ecode2 = 0 ;
21100 PyObject *swig_obj[2] ;
21101
21102 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21104 if (!SWIG_IsOK(res1)) {
21105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21106 }
21107 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21108 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21109 if (!SWIG_IsOK(ecode2)) {
21110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21111 }
21112 arg2 = static_cast< int >(val2);
21113 if (arg1) (arg1)->m_y = arg2;
21114
21115 resultobj = SWIG_Py_Void();
21116 return resultobj;
21117 fail:
21118 return NULL;
21119 }
21120
21121
21122 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21123 PyObject *resultobj = 0;
21124 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21125 int result;
21126 void *argp1 = 0 ;
21127 int res1 = 0 ;
21128 PyObject *swig_obj[1] ;
21129
21130 if (!args) SWIG_fail;
21131 swig_obj[0] = args;
21132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21133 if (!SWIG_IsOK(res1)) {
21134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21135 }
21136 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21137 result = (int) ((arg1)->m_y);
21138 resultobj = SWIG_From_int(static_cast< int >(result));
21139 return resultobj;
21140 fail:
21141 return NULL;
21142 }
21143
21144
21145 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21146 PyObject *resultobj = 0;
21147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21148 bool arg2 ;
21149 void *argp1 = 0 ;
21150 int res1 = 0 ;
21151 bool val2 ;
21152 int ecode2 = 0 ;
21153 PyObject *swig_obj[2] ;
21154
21155 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21157 if (!SWIG_IsOK(res1)) {
21158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21159 }
21160 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21161 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21162 if (!SWIG_IsOK(ecode2)) {
21163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21164 }
21165 arg2 = static_cast< bool >(val2);
21166 if (arg1) (arg1)->m_leftDown = arg2;
21167
21168 resultobj = SWIG_Py_Void();
21169 return resultobj;
21170 fail:
21171 return NULL;
21172 }
21173
21174
21175 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21176 PyObject *resultobj = 0;
21177 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21178 bool result;
21179 void *argp1 = 0 ;
21180 int res1 = 0 ;
21181 PyObject *swig_obj[1] ;
21182
21183 if (!args) SWIG_fail;
21184 swig_obj[0] = args;
21185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21186 if (!SWIG_IsOK(res1)) {
21187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21188 }
21189 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21190 result = (bool) ((arg1)->m_leftDown);
21191 {
21192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21193 }
21194 return resultobj;
21195 fail:
21196 return NULL;
21197 }
21198
21199
21200 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21201 PyObject *resultobj = 0;
21202 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21203 bool arg2 ;
21204 void *argp1 = 0 ;
21205 int res1 = 0 ;
21206 bool val2 ;
21207 int ecode2 = 0 ;
21208 PyObject *swig_obj[2] ;
21209
21210 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21212 if (!SWIG_IsOK(res1)) {
21213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21214 }
21215 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21216 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21217 if (!SWIG_IsOK(ecode2)) {
21218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21219 }
21220 arg2 = static_cast< bool >(val2);
21221 if (arg1) (arg1)->m_middleDown = arg2;
21222
21223 resultobj = SWIG_Py_Void();
21224 return resultobj;
21225 fail:
21226 return NULL;
21227 }
21228
21229
21230 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21231 PyObject *resultobj = 0;
21232 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21233 bool result;
21234 void *argp1 = 0 ;
21235 int res1 = 0 ;
21236 PyObject *swig_obj[1] ;
21237
21238 if (!args) SWIG_fail;
21239 swig_obj[0] = args;
21240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21241 if (!SWIG_IsOK(res1)) {
21242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21243 }
21244 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21245 result = (bool) ((arg1)->m_middleDown);
21246 {
21247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21248 }
21249 return resultobj;
21250 fail:
21251 return NULL;
21252 }
21253
21254
21255 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21256 PyObject *resultobj = 0;
21257 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21258 bool arg2 ;
21259 void *argp1 = 0 ;
21260 int res1 = 0 ;
21261 bool val2 ;
21262 int ecode2 = 0 ;
21263 PyObject *swig_obj[2] ;
21264
21265 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21267 if (!SWIG_IsOK(res1)) {
21268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21269 }
21270 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21271 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21272 if (!SWIG_IsOK(ecode2)) {
21273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21274 }
21275 arg2 = static_cast< bool >(val2);
21276 if (arg1) (arg1)->m_rightDown = arg2;
21277
21278 resultobj = SWIG_Py_Void();
21279 return resultobj;
21280 fail:
21281 return NULL;
21282 }
21283
21284
21285 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21286 PyObject *resultobj = 0;
21287 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21288 bool result;
21289 void *argp1 = 0 ;
21290 int res1 = 0 ;
21291 PyObject *swig_obj[1] ;
21292
21293 if (!args) SWIG_fail;
21294 swig_obj[0] = args;
21295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21296 if (!SWIG_IsOK(res1)) {
21297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21298 }
21299 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21300 result = (bool) ((arg1)->m_rightDown);
21301 {
21302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21303 }
21304 return resultobj;
21305 fail:
21306 return NULL;
21307 }
21308
21309
21310 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21311 PyObject *resultobj = 0;
21312 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21313 bool arg2 ;
21314 void *argp1 = 0 ;
21315 int res1 = 0 ;
21316 bool val2 ;
21317 int ecode2 = 0 ;
21318 PyObject *swig_obj[2] ;
21319
21320 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21322 if (!SWIG_IsOK(res1)) {
21323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21324 }
21325 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21326 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21327 if (!SWIG_IsOK(ecode2)) {
21328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21329 }
21330 arg2 = static_cast< bool >(val2);
21331 if (arg1) (arg1)->m_controlDown = arg2;
21332
21333 resultobj = SWIG_Py_Void();
21334 return resultobj;
21335 fail:
21336 return NULL;
21337 }
21338
21339
21340 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21341 PyObject *resultobj = 0;
21342 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21343 bool result;
21344 void *argp1 = 0 ;
21345 int res1 = 0 ;
21346 PyObject *swig_obj[1] ;
21347
21348 if (!args) SWIG_fail;
21349 swig_obj[0] = args;
21350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21351 if (!SWIG_IsOK(res1)) {
21352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21353 }
21354 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21355 result = (bool) ((arg1)->m_controlDown);
21356 {
21357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21358 }
21359 return resultobj;
21360 fail:
21361 return NULL;
21362 }
21363
21364
21365 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21366 PyObject *resultobj = 0;
21367 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21368 bool arg2 ;
21369 void *argp1 = 0 ;
21370 int res1 = 0 ;
21371 bool val2 ;
21372 int ecode2 = 0 ;
21373 PyObject *swig_obj[2] ;
21374
21375 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21377 if (!SWIG_IsOK(res1)) {
21378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21379 }
21380 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21381 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21382 if (!SWIG_IsOK(ecode2)) {
21383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21384 }
21385 arg2 = static_cast< bool >(val2);
21386 if (arg1) (arg1)->m_shiftDown = arg2;
21387
21388 resultobj = SWIG_Py_Void();
21389 return resultobj;
21390 fail:
21391 return NULL;
21392 }
21393
21394
21395 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21396 PyObject *resultobj = 0;
21397 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21398 bool result;
21399 void *argp1 = 0 ;
21400 int res1 = 0 ;
21401 PyObject *swig_obj[1] ;
21402
21403 if (!args) SWIG_fail;
21404 swig_obj[0] = args;
21405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21406 if (!SWIG_IsOK(res1)) {
21407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21408 }
21409 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21410 result = (bool) ((arg1)->m_shiftDown);
21411 {
21412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21413 }
21414 return resultobj;
21415 fail:
21416 return NULL;
21417 }
21418
21419
21420 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21421 PyObject *resultobj = 0;
21422 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21423 bool arg2 ;
21424 void *argp1 = 0 ;
21425 int res1 = 0 ;
21426 bool val2 ;
21427 int ecode2 = 0 ;
21428 PyObject *swig_obj[2] ;
21429
21430 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21432 if (!SWIG_IsOK(res1)) {
21433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21434 }
21435 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21436 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21437 if (!SWIG_IsOK(ecode2)) {
21438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21439 }
21440 arg2 = static_cast< bool >(val2);
21441 if (arg1) (arg1)->m_altDown = arg2;
21442
21443 resultobj = SWIG_Py_Void();
21444 return resultobj;
21445 fail:
21446 return NULL;
21447 }
21448
21449
21450 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21451 PyObject *resultobj = 0;
21452 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21453 bool result;
21454 void *argp1 = 0 ;
21455 int res1 = 0 ;
21456 PyObject *swig_obj[1] ;
21457
21458 if (!args) SWIG_fail;
21459 swig_obj[0] = args;
21460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21461 if (!SWIG_IsOK(res1)) {
21462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21463 }
21464 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21465 result = (bool) ((arg1)->m_altDown);
21466 {
21467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21468 }
21469 return resultobj;
21470 fail:
21471 return NULL;
21472 }
21473
21474
21475 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21476 PyObject *resultobj = 0;
21477 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21478 bool arg2 ;
21479 void *argp1 = 0 ;
21480 int res1 = 0 ;
21481 bool val2 ;
21482 int ecode2 = 0 ;
21483 PyObject *swig_obj[2] ;
21484
21485 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21487 if (!SWIG_IsOK(res1)) {
21488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21489 }
21490 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21491 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21492 if (!SWIG_IsOK(ecode2)) {
21493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21494 }
21495 arg2 = static_cast< bool >(val2);
21496 if (arg1) (arg1)->m_metaDown = arg2;
21497
21498 resultobj = SWIG_Py_Void();
21499 return resultobj;
21500 fail:
21501 return NULL;
21502 }
21503
21504
21505 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21506 PyObject *resultobj = 0;
21507 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21508 bool result;
21509 void *argp1 = 0 ;
21510 int res1 = 0 ;
21511 PyObject *swig_obj[1] ;
21512
21513 if (!args) SWIG_fail;
21514 swig_obj[0] = args;
21515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21516 if (!SWIG_IsOK(res1)) {
21517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21518 }
21519 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21520 result = (bool) ((arg1)->m_metaDown);
21521 {
21522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21523 }
21524 return resultobj;
21525 fail:
21526 return NULL;
21527 }
21528
21529
21530 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21531 PyObject *resultobj = 0;
21532 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21533 int arg2 ;
21534 void *argp1 = 0 ;
21535 int res1 = 0 ;
21536 int val2 ;
21537 int ecode2 = 0 ;
21538 PyObject *swig_obj[2] ;
21539
21540 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21542 if (!SWIG_IsOK(res1)) {
21543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21544 }
21545 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21546 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21547 if (!SWIG_IsOK(ecode2)) {
21548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21549 }
21550 arg2 = static_cast< int >(val2);
21551 if (arg1) (arg1)->m_wheelRotation = arg2;
21552
21553 resultobj = SWIG_Py_Void();
21554 return resultobj;
21555 fail:
21556 return NULL;
21557 }
21558
21559
21560 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21561 PyObject *resultobj = 0;
21562 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21563 int result;
21564 void *argp1 = 0 ;
21565 int res1 = 0 ;
21566 PyObject *swig_obj[1] ;
21567
21568 if (!args) SWIG_fail;
21569 swig_obj[0] = args;
21570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21571 if (!SWIG_IsOK(res1)) {
21572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21573 }
21574 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21575 result = (int) ((arg1)->m_wheelRotation);
21576 resultobj = SWIG_From_int(static_cast< int >(result));
21577 return resultobj;
21578 fail:
21579 return NULL;
21580 }
21581
21582
21583 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21584 PyObject *resultobj = 0;
21585 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21586 int arg2 ;
21587 void *argp1 = 0 ;
21588 int res1 = 0 ;
21589 int val2 ;
21590 int ecode2 = 0 ;
21591 PyObject *swig_obj[2] ;
21592
21593 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21595 if (!SWIG_IsOK(res1)) {
21596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21597 }
21598 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21599 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21600 if (!SWIG_IsOK(ecode2)) {
21601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21602 }
21603 arg2 = static_cast< int >(val2);
21604 if (arg1) (arg1)->m_wheelDelta = arg2;
21605
21606 resultobj = SWIG_Py_Void();
21607 return resultobj;
21608 fail:
21609 return NULL;
21610 }
21611
21612
21613 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21614 PyObject *resultobj = 0;
21615 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21616 int result;
21617 void *argp1 = 0 ;
21618 int res1 = 0 ;
21619 PyObject *swig_obj[1] ;
21620
21621 if (!args) SWIG_fail;
21622 swig_obj[0] = args;
21623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21624 if (!SWIG_IsOK(res1)) {
21625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21626 }
21627 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21628 result = (int) ((arg1)->m_wheelDelta);
21629 resultobj = SWIG_From_int(static_cast< int >(result));
21630 return resultobj;
21631 fail:
21632 return NULL;
21633 }
21634
21635
21636 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21637 PyObject *resultobj = 0;
21638 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21639 int arg2 ;
21640 void *argp1 = 0 ;
21641 int res1 = 0 ;
21642 int val2 ;
21643 int ecode2 = 0 ;
21644 PyObject *swig_obj[2] ;
21645
21646 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21648 if (!SWIG_IsOK(res1)) {
21649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21650 }
21651 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21652 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21653 if (!SWIG_IsOK(ecode2)) {
21654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21655 }
21656 arg2 = static_cast< int >(val2);
21657 if (arg1) (arg1)->m_linesPerAction = arg2;
21658
21659 resultobj = SWIG_Py_Void();
21660 return resultobj;
21661 fail:
21662 return NULL;
21663 }
21664
21665
21666 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21667 PyObject *resultobj = 0;
21668 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21669 int result;
21670 void *argp1 = 0 ;
21671 int res1 = 0 ;
21672 PyObject *swig_obj[1] ;
21673
21674 if (!args) SWIG_fail;
21675 swig_obj[0] = args;
21676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21677 if (!SWIG_IsOK(res1)) {
21678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21679 }
21680 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21681 result = (int) ((arg1)->m_linesPerAction);
21682 resultobj = SWIG_From_int(static_cast< int >(result));
21683 return resultobj;
21684 fail:
21685 return NULL;
21686 }
21687
21688
21689 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21690 PyObject *obj;
21691 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21692 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21693 return SWIG_Py_Void();
21694 }
21695
21696 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21697 return SWIG_Python_InitShadowInstance(args);
21698 }
21699
21700 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21701 PyObject *resultobj = 0;
21702 int arg1 = (int) 0 ;
21703 int arg2 = (int) 0 ;
21704 wxSetCursorEvent *result = 0 ;
21705 int val1 ;
21706 int ecode1 = 0 ;
21707 int val2 ;
21708 int ecode2 = 0 ;
21709 PyObject * obj0 = 0 ;
21710 PyObject * obj1 = 0 ;
21711 char * kwnames[] = {
21712 (char *) "x",(char *) "y", NULL
21713 };
21714
21715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21716 if (obj0) {
21717 ecode1 = SWIG_AsVal_int(obj0, &val1);
21718 if (!SWIG_IsOK(ecode1)) {
21719 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21720 }
21721 arg1 = static_cast< int >(val1);
21722 }
21723 if (obj1) {
21724 ecode2 = SWIG_AsVal_int(obj1, &val2);
21725 if (!SWIG_IsOK(ecode2)) {
21726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21727 }
21728 arg2 = static_cast< int >(val2);
21729 }
21730 {
21731 PyThreadState* __tstate = wxPyBeginAllowThreads();
21732 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21733 wxPyEndAllowThreads(__tstate);
21734 if (PyErr_Occurred()) SWIG_fail;
21735 }
21736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21737 return resultobj;
21738 fail:
21739 return NULL;
21740 }
21741
21742
21743 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21744 PyObject *resultobj = 0;
21745 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21746 int result;
21747 void *argp1 = 0 ;
21748 int res1 = 0 ;
21749 PyObject *swig_obj[1] ;
21750
21751 if (!args) SWIG_fail;
21752 swig_obj[0] = args;
21753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21754 if (!SWIG_IsOK(res1)) {
21755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21756 }
21757 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21758 {
21759 PyThreadState* __tstate = wxPyBeginAllowThreads();
21760 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21761 wxPyEndAllowThreads(__tstate);
21762 if (PyErr_Occurred()) SWIG_fail;
21763 }
21764 resultobj = SWIG_From_int(static_cast< int >(result));
21765 return resultobj;
21766 fail:
21767 return NULL;
21768 }
21769
21770
21771 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21772 PyObject *resultobj = 0;
21773 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21774 int result;
21775 void *argp1 = 0 ;
21776 int res1 = 0 ;
21777 PyObject *swig_obj[1] ;
21778
21779 if (!args) SWIG_fail;
21780 swig_obj[0] = args;
21781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21782 if (!SWIG_IsOK(res1)) {
21783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21784 }
21785 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21786 {
21787 PyThreadState* __tstate = wxPyBeginAllowThreads();
21788 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21789 wxPyEndAllowThreads(__tstate);
21790 if (PyErr_Occurred()) SWIG_fail;
21791 }
21792 resultobj = SWIG_From_int(static_cast< int >(result));
21793 return resultobj;
21794 fail:
21795 return NULL;
21796 }
21797
21798
21799 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21800 PyObject *resultobj = 0;
21801 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21802 wxCursor *arg2 = 0 ;
21803 void *argp1 = 0 ;
21804 int res1 = 0 ;
21805 void *argp2 = 0 ;
21806 int res2 = 0 ;
21807 PyObject * obj0 = 0 ;
21808 PyObject * obj1 = 0 ;
21809 char * kwnames[] = {
21810 (char *) "self",(char *) "cursor", NULL
21811 };
21812
21813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21815 if (!SWIG_IsOK(res1)) {
21816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21817 }
21818 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21819 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21820 if (!SWIG_IsOK(res2)) {
21821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21822 }
21823 if (!argp2) {
21824 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21825 }
21826 arg2 = reinterpret_cast< wxCursor * >(argp2);
21827 {
21828 PyThreadState* __tstate = wxPyBeginAllowThreads();
21829 (arg1)->SetCursor((wxCursor const &)*arg2);
21830 wxPyEndAllowThreads(__tstate);
21831 if (PyErr_Occurred()) SWIG_fail;
21832 }
21833 resultobj = SWIG_Py_Void();
21834 return resultobj;
21835 fail:
21836 return NULL;
21837 }
21838
21839
21840 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21841 PyObject *resultobj = 0;
21842 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21843 wxCursor *result = 0 ;
21844 void *argp1 = 0 ;
21845 int res1 = 0 ;
21846 PyObject *swig_obj[1] ;
21847
21848 if (!args) SWIG_fail;
21849 swig_obj[0] = args;
21850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21851 if (!SWIG_IsOK(res1)) {
21852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21853 }
21854 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21855 {
21856 PyThreadState* __tstate = wxPyBeginAllowThreads();
21857 {
21858 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21859 result = (wxCursor *) &_result_ref;
21860 }
21861 wxPyEndAllowThreads(__tstate);
21862 if (PyErr_Occurred()) SWIG_fail;
21863 }
21864 {
21865 wxCursor* resultptr = new wxCursor(*result);
21866 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21867 }
21868 return resultobj;
21869 fail:
21870 return NULL;
21871 }
21872
21873
21874 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21875 PyObject *resultobj = 0;
21876 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21877 bool result;
21878 void *argp1 = 0 ;
21879 int res1 = 0 ;
21880 PyObject *swig_obj[1] ;
21881
21882 if (!args) SWIG_fail;
21883 swig_obj[0] = args;
21884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21885 if (!SWIG_IsOK(res1)) {
21886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21887 }
21888 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21889 {
21890 PyThreadState* __tstate = wxPyBeginAllowThreads();
21891 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21892 wxPyEndAllowThreads(__tstate);
21893 if (PyErr_Occurred()) SWIG_fail;
21894 }
21895 {
21896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21897 }
21898 return resultobj;
21899 fail:
21900 return NULL;
21901 }
21902
21903
21904 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21905 PyObject *obj;
21906 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21907 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21908 return SWIG_Py_Void();
21909 }
21910
21911 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21912 return SWIG_Python_InitShadowInstance(args);
21913 }
21914
21915 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21916 PyObject *resultobj = 0;
21917 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21918 wxKeyEvent *result = 0 ;
21919 int val1 ;
21920 int ecode1 = 0 ;
21921 PyObject * obj0 = 0 ;
21922 char * kwnames[] = {
21923 (char *) "eventType", NULL
21924 };
21925
21926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21927 if (obj0) {
21928 ecode1 = SWIG_AsVal_int(obj0, &val1);
21929 if (!SWIG_IsOK(ecode1)) {
21930 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21931 }
21932 arg1 = static_cast< wxEventType >(val1);
21933 }
21934 {
21935 PyThreadState* __tstate = wxPyBeginAllowThreads();
21936 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21937 wxPyEndAllowThreads(__tstate);
21938 if (PyErr_Occurred()) SWIG_fail;
21939 }
21940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21941 return resultobj;
21942 fail:
21943 return NULL;
21944 }
21945
21946
21947 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21948 PyObject *resultobj = 0;
21949 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21950 int result;
21951 void *argp1 = 0 ;
21952 int res1 = 0 ;
21953 PyObject *swig_obj[1] ;
21954
21955 if (!args) SWIG_fail;
21956 swig_obj[0] = args;
21957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21958 if (!SWIG_IsOK(res1)) {
21959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21960 }
21961 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21962 {
21963 PyThreadState* __tstate = wxPyBeginAllowThreads();
21964 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21965 wxPyEndAllowThreads(__tstate);
21966 if (PyErr_Occurred()) SWIG_fail;
21967 }
21968 resultobj = SWIG_From_int(static_cast< int >(result));
21969 return resultobj;
21970 fail:
21971 return NULL;
21972 }
21973
21974
21975 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21976 PyObject *resultobj = 0;
21977 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21978 bool result;
21979 void *argp1 = 0 ;
21980 int res1 = 0 ;
21981 PyObject *swig_obj[1] ;
21982
21983 if (!args) SWIG_fail;
21984 swig_obj[0] = args;
21985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21986 if (!SWIG_IsOK(res1)) {
21987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21988 }
21989 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21990 {
21991 PyThreadState* __tstate = wxPyBeginAllowThreads();
21992 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21993 wxPyEndAllowThreads(__tstate);
21994 if (PyErr_Occurred()) SWIG_fail;
21995 }
21996 {
21997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21998 }
21999 return resultobj;
22000 fail:
22001 return NULL;
22002 }
22003
22004
22005 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22006 PyObject *resultobj = 0;
22007 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22008 bool result;
22009 void *argp1 = 0 ;
22010 int res1 = 0 ;
22011 PyObject *swig_obj[1] ;
22012
22013 if (!args) SWIG_fail;
22014 swig_obj[0] = args;
22015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22016 if (!SWIG_IsOK(res1)) {
22017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22018 }
22019 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22020 {
22021 PyThreadState* __tstate = wxPyBeginAllowThreads();
22022 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22023 wxPyEndAllowThreads(__tstate);
22024 if (PyErr_Occurred()) SWIG_fail;
22025 }
22026 {
22027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22028 }
22029 return resultobj;
22030 fail:
22031 return NULL;
22032 }
22033
22034
22035 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22036 PyObject *resultobj = 0;
22037 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22038 bool result;
22039 void *argp1 = 0 ;
22040 int res1 = 0 ;
22041 PyObject *swig_obj[1] ;
22042
22043 if (!args) SWIG_fail;
22044 swig_obj[0] = args;
22045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22046 if (!SWIG_IsOK(res1)) {
22047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22048 }
22049 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22050 {
22051 PyThreadState* __tstate = wxPyBeginAllowThreads();
22052 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22053 wxPyEndAllowThreads(__tstate);
22054 if (PyErr_Occurred()) SWIG_fail;
22055 }
22056 {
22057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22058 }
22059 return resultobj;
22060 fail:
22061 return NULL;
22062 }
22063
22064
22065 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22066 PyObject *resultobj = 0;
22067 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22068 bool result;
22069 void *argp1 = 0 ;
22070 int res1 = 0 ;
22071 PyObject *swig_obj[1] ;
22072
22073 if (!args) SWIG_fail;
22074 swig_obj[0] = args;
22075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22076 if (!SWIG_IsOK(res1)) {
22077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22078 }
22079 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22080 {
22081 PyThreadState* __tstate = wxPyBeginAllowThreads();
22082 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22083 wxPyEndAllowThreads(__tstate);
22084 if (PyErr_Occurred()) SWIG_fail;
22085 }
22086 {
22087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22088 }
22089 return resultobj;
22090 fail:
22091 return NULL;
22092 }
22093
22094
22095 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22096 PyObject *resultobj = 0;
22097 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22098 bool result;
22099 void *argp1 = 0 ;
22100 int res1 = 0 ;
22101 PyObject *swig_obj[1] ;
22102
22103 if (!args) SWIG_fail;
22104 swig_obj[0] = args;
22105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22106 if (!SWIG_IsOK(res1)) {
22107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22108 }
22109 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22110 {
22111 PyThreadState* __tstate = wxPyBeginAllowThreads();
22112 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22113 wxPyEndAllowThreads(__tstate);
22114 if (PyErr_Occurred()) SWIG_fail;
22115 }
22116 {
22117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22118 }
22119 return resultobj;
22120 fail:
22121 return NULL;
22122 }
22123
22124
22125 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22126 PyObject *resultobj = 0;
22127 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22128 bool result;
22129 void *argp1 = 0 ;
22130 int res1 = 0 ;
22131 PyObject *swig_obj[1] ;
22132
22133 if (!args) SWIG_fail;
22134 swig_obj[0] = args;
22135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22136 if (!SWIG_IsOK(res1)) {
22137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22138 }
22139 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22140 {
22141 PyThreadState* __tstate = wxPyBeginAllowThreads();
22142 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22143 wxPyEndAllowThreads(__tstate);
22144 if (PyErr_Occurred()) SWIG_fail;
22145 }
22146 {
22147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22148 }
22149 return resultobj;
22150 fail:
22151 return NULL;
22152 }
22153
22154
22155 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22156 PyObject *resultobj = 0;
22157 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22158 int result;
22159 void *argp1 = 0 ;
22160 int res1 = 0 ;
22161 PyObject *swig_obj[1] ;
22162
22163 if (!args) SWIG_fail;
22164 swig_obj[0] = args;
22165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22166 if (!SWIG_IsOK(res1)) {
22167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22168 }
22169 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22170 {
22171 PyThreadState* __tstate = wxPyBeginAllowThreads();
22172 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22173 wxPyEndAllowThreads(__tstate);
22174 if (PyErr_Occurred()) SWIG_fail;
22175 }
22176 resultobj = SWIG_From_int(static_cast< int >(result));
22177 return resultobj;
22178 fail:
22179 return NULL;
22180 }
22181
22182
22183 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22184 PyObject *resultobj = 0;
22185 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22186 int result;
22187 void *argp1 = 0 ;
22188 int res1 = 0 ;
22189 PyObject *swig_obj[1] ;
22190
22191 if (!args) SWIG_fail;
22192 swig_obj[0] = args;
22193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22194 if (!SWIG_IsOK(res1)) {
22195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22196 }
22197 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22198 {
22199 PyThreadState* __tstate = wxPyBeginAllowThreads();
22200 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22201 wxPyEndAllowThreads(__tstate);
22202 if (PyErr_Occurred()) SWIG_fail;
22203 }
22204 resultobj = SWIG_From_int(static_cast< int >(result));
22205 return resultobj;
22206 fail:
22207 return NULL;
22208 }
22209
22210
22211 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22212 PyObject *resultobj = 0;
22213 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22214 int arg2 ;
22215 void *argp1 = 0 ;
22216 int res1 = 0 ;
22217 int val2 ;
22218 int ecode2 = 0 ;
22219 PyObject * obj0 = 0 ;
22220 PyObject * obj1 = 0 ;
22221 char * kwnames[] = {
22222 (char *) "self",(char *) "uniChar", NULL
22223 };
22224
22225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22227 if (!SWIG_IsOK(res1)) {
22228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22229 }
22230 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22231 ecode2 = SWIG_AsVal_int(obj1, &val2);
22232 if (!SWIG_IsOK(ecode2)) {
22233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22234 }
22235 arg2 = static_cast< int >(val2);
22236 {
22237 PyThreadState* __tstate = wxPyBeginAllowThreads();
22238 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22239 wxPyEndAllowThreads(__tstate);
22240 if (PyErr_Occurred()) SWIG_fail;
22241 }
22242 resultobj = SWIG_Py_Void();
22243 return resultobj;
22244 fail:
22245 return NULL;
22246 }
22247
22248
22249 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22250 PyObject *resultobj = 0;
22251 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22252 unsigned int result;
22253 void *argp1 = 0 ;
22254 int res1 = 0 ;
22255 PyObject *swig_obj[1] ;
22256
22257 if (!args) SWIG_fail;
22258 swig_obj[0] = args;
22259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22260 if (!SWIG_IsOK(res1)) {
22261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22262 }
22263 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22264 {
22265 PyThreadState* __tstate = wxPyBeginAllowThreads();
22266 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22267 wxPyEndAllowThreads(__tstate);
22268 if (PyErr_Occurred()) SWIG_fail;
22269 }
22270 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22271 return resultobj;
22272 fail:
22273 return NULL;
22274 }
22275
22276
22277 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22278 PyObject *resultobj = 0;
22279 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22280 unsigned int result;
22281 void *argp1 = 0 ;
22282 int res1 = 0 ;
22283 PyObject *swig_obj[1] ;
22284
22285 if (!args) SWIG_fail;
22286 swig_obj[0] = args;
22287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22288 if (!SWIG_IsOK(res1)) {
22289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22290 }
22291 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22292 {
22293 PyThreadState* __tstate = wxPyBeginAllowThreads();
22294 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22295 wxPyEndAllowThreads(__tstate);
22296 if (PyErr_Occurred()) SWIG_fail;
22297 }
22298 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22299 return resultobj;
22300 fail:
22301 return NULL;
22302 }
22303
22304
22305 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22306 PyObject *resultobj = 0;
22307 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22308 wxPoint result;
22309 void *argp1 = 0 ;
22310 int res1 = 0 ;
22311 PyObject *swig_obj[1] ;
22312
22313 if (!args) SWIG_fail;
22314 swig_obj[0] = args;
22315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22316 if (!SWIG_IsOK(res1)) {
22317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22318 }
22319 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22320 {
22321 PyThreadState* __tstate = wxPyBeginAllowThreads();
22322 result = (arg1)->GetPosition();
22323 wxPyEndAllowThreads(__tstate);
22324 if (PyErr_Occurred()) SWIG_fail;
22325 }
22326 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22327 return resultobj;
22328 fail:
22329 return NULL;
22330 }
22331
22332
22333 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22334 PyObject *resultobj = 0;
22335 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22336 long *arg2 = (long *) 0 ;
22337 long *arg3 = (long *) 0 ;
22338 void *argp1 = 0 ;
22339 int res1 = 0 ;
22340 long temp2 ;
22341 int res2 = SWIG_TMPOBJ ;
22342 long temp3 ;
22343 int res3 = SWIG_TMPOBJ ;
22344 PyObject *swig_obj[1] ;
22345
22346 arg2 = &temp2;
22347 arg3 = &temp3;
22348 if (!args) SWIG_fail;
22349 swig_obj[0] = args;
22350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22351 if (!SWIG_IsOK(res1)) {
22352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22353 }
22354 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22355 {
22356 PyThreadState* __tstate = wxPyBeginAllowThreads();
22357 (arg1)->GetPosition(arg2,arg3);
22358 wxPyEndAllowThreads(__tstate);
22359 if (PyErr_Occurred()) SWIG_fail;
22360 }
22361 resultobj = SWIG_Py_Void();
22362 if (SWIG_IsTmpObj(res2)) {
22363 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22364 } else {
22365 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22366 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22367 }
22368 if (SWIG_IsTmpObj(res3)) {
22369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22370 } else {
22371 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22373 }
22374 return resultobj;
22375 fail:
22376 return NULL;
22377 }
22378
22379
22380 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22381 PyObject *resultobj = 0;
22382 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22383 int result;
22384 void *argp1 = 0 ;
22385 int res1 = 0 ;
22386 PyObject *swig_obj[1] ;
22387
22388 if (!args) SWIG_fail;
22389 swig_obj[0] = args;
22390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22391 if (!SWIG_IsOK(res1)) {
22392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22393 }
22394 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22395 {
22396 PyThreadState* __tstate = wxPyBeginAllowThreads();
22397 result = (int)((wxKeyEvent const *)arg1)->GetX();
22398 wxPyEndAllowThreads(__tstate);
22399 if (PyErr_Occurred()) SWIG_fail;
22400 }
22401 resultobj = SWIG_From_int(static_cast< int >(result));
22402 return resultobj;
22403 fail:
22404 return NULL;
22405 }
22406
22407
22408 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22409 PyObject *resultobj = 0;
22410 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22411 int result;
22412 void *argp1 = 0 ;
22413 int res1 = 0 ;
22414 PyObject *swig_obj[1] ;
22415
22416 if (!args) SWIG_fail;
22417 swig_obj[0] = args;
22418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22419 if (!SWIG_IsOK(res1)) {
22420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22421 }
22422 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22423 {
22424 PyThreadState* __tstate = wxPyBeginAllowThreads();
22425 result = (int)((wxKeyEvent const *)arg1)->GetY();
22426 wxPyEndAllowThreads(__tstate);
22427 if (PyErr_Occurred()) SWIG_fail;
22428 }
22429 resultobj = SWIG_From_int(static_cast< int >(result));
22430 return resultobj;
22431 fail:
22432 return NULL;
22433 }
22434
22435
22436 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22437 PyObject *resultobj = 0;
22438 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22439 int arg2 ;
22440 void *argp1 = 0 ;
22441 int res1 = 0 ;
22442 int val2 ;
22443 int ecode2 = 0 ;
22444 PyObject *swig_obj[2] ;
22445
22446 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22448 if (!SWIG_IsOK(res1)) {
22449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22450 }
22451 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22452 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22453 if (!SWIG_IsOK(ecode2)) {
22454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22455 }
22456 arg2 = static_cast< int >(val2);
22457 if (arg1) (arg1)->m_x = arg2;
22458
22459 resultobj = SWIG_Py_Void();
22460 return resultobj;
22461 fail:
22462 return NULL;
22463 }
22464
22465
22466 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22467 PyObject *resultobj = 0;
22468 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22469 int result;
22470 void *argp1 = 0 ;
22471 int res1 = 0 ;
22472 PyObject *swig_obj[1] ;
22473
22474 if (!args) SWIG_fail;
22475 swig_obj[0] = args;
22476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22477 if (!SWIG_IsOK(res1)) {
22478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22479 }
22480 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22481 result = (int) ((arg1)->m_x);
22482 resultobj = SWIG_From_int(static_cast< int >(result));
22483 return resultobj;
22484 fail:
22485 return NULL;
22486 }
22487
22488
22489 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22490 PyObject *resultobj = 0;
22491 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22492 int arg2 ;
22493 void *argp1 = 0 ;
22494 int res1 = 0 ;
22495 int val2 ;
22496 int ecode2 = 0 ;
22497 PyObject *swig_obj[2] ;
22498
22499 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22501 if (!SWIG_IsOK(res1)) {
22502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22503 }
22504 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22505 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22506 if (!SWIG_IsOK(ecode2)) {
22507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22508 }
22509 arg2 = static_cast< int >(val2);
22510 if (arg1) (arg1)->m_y = arg2;
22511
22512 resultobj = SWIG_Py_Void();
22513 return resultobj;
22514 fail:
22515 return NULL;
22516 }
22517
22518
22519 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22520 PyObject *resultobj = 0;
22521 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22522 int result;
22523 void *argp1 = 0 ;
22524 int res1 = 0 ;
22525 PyObject *swig_obj[1] ;
22526
22527 if (!args) SWIG_fail;
22528 swig_obj[0] = args;
22529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22530 if (!SWIG_IsOK(res1)) {
22531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22532 }
22533 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22534 result = (int) ((arg1)->m_y);
22535 resultobj = SWIG_From_int(static_cast< int >(result));
22536 return resultobj;
22537 fail:
22538 return NULL;
22539 }
22540
22541
22542 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22543 PyObject *resultobj = 0;
22544 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22545 long arg2 ;
22546 void *argp1 = 0 ;
22547 int res1 = 0 ;
22548 long val2 ;
22549 int ecode2 = 0 ;
22550 PyObject *swig_obj[2] ;
22551
22552 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22554 if (!SWIG_IsOK(res1)) {
22555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22556 }
22557 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22558 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22559 if (!SWIG_IsOK(ecode2)) {
22560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22561 }
22562 arg2 = static_cast< long >(val2);
22563 if (arg1) (arg1)->m_keyCode = arg2;
22564
22565 resultobj = SWIG_Py_Void();
22566 return resultobj;
22567 fail:
22568 return NULL;
22569 }
22570
22571
22572 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22573 PyObject *resultobj = 0;
22574 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22575 long result;
22576 void *argp1 = 0 ;
22577 int res1 = 0 ;
22578 PyObject *swig_obj[1] ;
22579
22580 if (!args) SWIG_fail;
22581 swig_obj[0] = args;
22582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22583 if (!SWIG_IsOK(res1)) {
22584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22585 }
22586 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22587 result = (long) ((arg1)->m_keyCode);
22588 resultobj = SWIG_From_long(static_cast< long >(result));
22589 return resultobj;
22590 fail:
22591 return NULL;
22592 }
22593
22594
22595 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22596 PyObject *resultobj = 0;
22597 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22598 bool arg2 ;
22599 void *argp1 = 0 ;
22600 int res1 = 0 ;
22601 bool val2 ;
22602 int ecode2 = 0 ;
22603 PyObject *swig_obj[2] ;
22604
22605 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22607 if (!SWIG_IsOK(res1)) {
22608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22609 }
22610 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22611 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22612 if (!SWIG_IsOK(ecode2)) {
22613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22614 }
22615 arg2 = static_cast< bool >(val2);
22616 if (arg1) (arg1)->m_controlDown = arg2;
22617
22618 resultobj = SWIG_Py_Void();
22619 return resultobj;
22620 fail:
22621 return NULL;
22622 }
22623
22624
22625 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22626 PyObject *resultobj = 0;
22627 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22628 bool result;
22629 void *argp1 = 0 ;
22630 int res1 = 0 ;
22631 PyObject *swig_obj[1] ;
22632
22633 if (!args) SWIG_fail;
22634 swig_obj[0] = args;
22635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22636 if (!SWIG_IsOK(res1)) {
22637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22638 }
22639 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22640 result = (bool) ((arg1)->m_controlDown);
22641 {
22642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22643 }
22644 return resultobj;
22645 fail:
22646 return NULL;
22647 }
22648
22649
22650 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22651 PyObject *resultobj = 0;
22652 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22653 bool arg2 ;
22654 void *argp1 = 0 ;
22655 int res1 = 0 ;
22656 bool val2 ;
22657 int ecode2 = 0 ;
22658 PyObject *swig_obj[2] ;
22659
22660 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22662 if (!SWIG_IsOK(res1)) {
22663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22664 }
22665 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22666 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22667 if (!SWIG_IsOK(ecode2)) {
22668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22669 }
22670 arg2 = static_cast< bool >(val2);
22671 if (arg1) (arg1)->m_shiftDown = arg2;
22672
22673 resultobj = SWIG_Py_Void();
22674 return resultobj;
22675 fail:
22676 return NULL;
22677 }
22678
22679
22680 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22681 PyObject *resultobj = 0;
22682 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22683 bool result;
22684 void *argp1 = 0 ;
22685 int res1 = 0 ;
22686 PyObject *swig_obj[1] ;
22687
22688 if (!args) SWIG_fail;
22689 swig_obj[0] = args;
22690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22691 if (!SWIG_IsOK(res1)) {
22692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22693 }
22694 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22695 result = (bool) ((arg1)->m_shiftDown);
22696 {
22697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22698 }
22699 return resultobj;
22700 fail:
22701 return NULL;
22702 }
22703
22704
22705 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22706 PyObject *resultobj = 0;
22707 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22708 bool arg2 ;
22709 void *argp1 = 0 ;
22710 int res1 = 0 ;
22711 bool val2 ;
22712 int ecode2 = 0 ;
22713 PyObject *swig_obj[2] ;
22714
22715 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22717 if (!SWIG_IsOK(res1)) {
22718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22719 }
22720 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22721 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22722 if (!SWIG_IsOK(ecode2)) {
22723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22724 }
22725 arg2 = static_cast< bool >(val2);
22726 if (arg1) (arg1)->m_altDown = arg2;
22727
22728 resultobj = SWIG_Py_Void();
22729 return resultobj;
22730 fail:
22731 return NULL;
22732 }
22733
22734
22735 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22736 PyObject *resultobj = 0;
22737 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22738 bool result;
22739 void *argp1 = 0 ;
22740 int res1 = 0 ;
22741 PyObject *swig_obj[1] ;
22742
22743 if (!args) SWIG_fail;
22744 swig_obj[0] = args;
22745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22746 if (!SWIG_IsOK(res1)) {
22747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22748 }
22749 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22750 result = (bool) ((arg1)->m_altDown);
22751 {
22752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22753 }
22754 return resultobj;
22755 fail:
22756 return NULL;
22757 }
22758
22759
22760 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22761 PyObject *resultobj = 0;
22762 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22763 bool arg2 ;
22764 void *argp1 = 0 ;
22765 int res1 = 0 ;
22766 bool val2 ;
22767 int ecode2 = 0 ;
22768 PyObject *swig_obj[2] ;
22769
22770 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22772 if (!SWIG_IsOK(res1)) {
22773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22774 }
22775 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22776 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22777 if (!SWIG_IsOK(ecode2)) {
22778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22779 }
22780 arg2 = static_cast< bool >(val2);
22781 if (arg1) (arg1)->m_metaDown = arg2;
22782
22783 resultobj = SWIG_Py_Void();
22784 return resultobj;
22785 fail:
22786 return NULL;
22787 }
22788
22789
22790 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22791 PyObject *resultobj = 0;
22792 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22793 bool result;
22794 void *argp1 = 0 ;
22795 int res1 = 0 ;
22796 PyObject *swig_obj[1] ;
22797
22798 if (!args) SWIG_fail;
22799 swig_obj[0] = args;
22800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22801 if (!SWIG_IsOK(res1)) {
22802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22803 }
22804 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22805 result = (bool) ((arg1)->m_metaDown);
22806 {
22807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22808 }
22809 return resultobj;
22810 fail:
22811 return NULL;
22812 }
22813
22814
22815 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22816 PyObject *resultobj = 0;
22817 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22818 bool arg2 ;
22819 void *argp1 = 0 ;
22820 int res1 = 0 ;
22821 bool val2 ;
22822 int ecode2 = 0 ;
22823 PyObject *swig_obj[2] ;
22824
22825 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22827 if (!SWIG_IsOK(res1)) {
22828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22829 }
22830 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22831 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22832 if (!SWIG_IsOK(ecode2)) {
22833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22834 }
22835 arg2 = static_cast< bool >(val2);
22836 if (arg1) (arg1)->m_scanCode = arg2;
22837
22838 resultobj = SWIG_Py_Void();
22839 return resultobj;
22840 fail:
22841 return NULL;
22842 }
22843
22844
22845 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22846 PyObject *resultobj = 0;
22847 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22848 bool result;
22849 void *argp1 = 0 ;
22850 int res1 = 0 ;
22851 PyObject *swig_obj[1] ;
22852
22853 if (!args) SWIG_fail;
22854 swig_obj[0] = args;
22855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22856 if (!SWIG_IsOK(res1)) {
22857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22858 }
22859 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22860 result = (bool) ((arg1)->m_scanCode);
22861 {
22862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22863 }
22864 return resultobj;
22865 fail:
22866 return NULL;
22867 }
22868
22869
22870 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22871 PyObject *resultobj = 0;
22872 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22873 unsigned int arg2 ;
22874 void *argp1 = 0 ;
22875 int res1 = 0 ;
22876 unsigned int val2 ;
22877 int ecode2 = 0 ;
22878 PyObject *swig_obj[2] ;
22879
22880 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22882 if (!SWIG_IsOK(res1)) {
22883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22884 }
22885 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22886 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22887 if (!SWIG_IsOK(ecode2)) {
22888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22889 }
22890 arg2 = static_cast< unsigned int >(val2);
22891 if (arg1) (arg1)->m_rawCode = arg2;
22892
22893 resultobj = SWIG_Py_Void();
22894 return resultobj;
22895 fail:
22896 return NULL;
22897 }
22898
22899
22900 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22901 PyObject *resultobj = 0;
22902 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22903 unsigned int result;
22904 void *argp1 = 0 ;
22905 int res1 = 0 ;
22906 PyObject *swig_obj[1] ;
22907
22908 if (!args) SWIG_fail;
22909 swig_obj[0] = args;
22910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22911 if (!SWIG_IsOK(res1)) {
22912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22913 }
22914 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22915 result = (unsigned int) ((arg1)->m_rawCode);
22916 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22917 return resultobj;
22918 fail:
22919 return NULL;
22920 }
22921
22922
22923 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22924 PyObject *resultobj = 0;
22925 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22926 unsigned int arg2 ;
22927 void *argp1 = 0 ;
22928 int res1 = 0 ;
22929 unsigned int val2 ;
22930 int ecode2 = 0 ;
22931 PyObject *swig_obj[2] ;
22932
22933 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22935 if (!SWIG_IsOK(res1)) {
22936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22937 }
22938 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22939 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22940 if (!SWIG_IsOK(ecode2)) {
22941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22942 }
22943 arg2 = static_cast< unsigned int >(val2);
22944 if (arg1) (arg1)->m_rawFlags = arg2;
22945
22946 resultobj = SWIG_Py_Void();
22947 return resultobj;
22948 fail:
22949 return NULL;
22950 }
22951
22952
22953 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22954 PyObject *resultobj = 0;
22955 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22956 unsigned int result;
22957 void *argp1 = 0 ;
22958 int res1 = 0 ;
22959 PyObject *swig_obj[1] ;
22960
22961 if (!args) SWIG_fail;
22962 swig_obj[0] = args;
22963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22964 if (!SWIG_IsOK(res1)) {
22965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22966 }
22967 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22968 result = (unsigned int) ((arg1)->m_rawFlags);
22969 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22970 return resultobj;
22971 fail:
22972 return NULL;
22973 }
22974
22975
22976 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22977 PyObject *obj;
22978 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22979 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22980 return SWIG_Py_Void();
22981 }
22982
22983 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22984 return SWIG_Python_InitShadowInstance(args);
22985 }
22986
22987 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22988 PyObject *resultobj = 0;
22989 wxSize const &arg1_defvalue = wxDefaultSize ;
22990 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22991 int arg2 = (int) 0 ;
22992 wxSizeEvent *result = 0 ;
22993 wxSize temp1 ;
22994 int val2 ;
22995 int ecode2 = 0 ;
22996 PyObject * obj0 = 0 ;
22997 PyObject * obj1 = 0 ;
22998 char * kwnames[] = {
22999 (char *) "sz",(char *) "winid", NULL
23000 };
23001
23002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23003 if (obj0) {
23004 {
23005 arg1 = &temp1;
23006 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23007 }
23008 }
23009 if (obj1) {
23010 ecode2 = SWIG_AsVal_int(obj1, &val2);
23011 if (!SWIG_IsOK(ecode2)) {
23012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23013 }
23014 arg2 = static_cast< int >(val2);
23015 }
23016 {
23017 PyThreadState* __tstate = wxPyBeginAllowThreads();
23018 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23019 wxPyEndAllowThreads(__tstate);
23020 if (PyErr_Occurred()) SWIG_fail;
23021 }
23022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23023 return resultobj;
23024 fail:
23025 return NULL;
23026 }
23027
23028
23029 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23030 PyObject *resultobj = 0;
23031 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23032 wxSize result;
23033 void *argp1 = 0 ;
23034 int res1 = 0 ;
23035 PyObject *swig_obj[1] ;
23036
23037 if (!args) SWIG_fail;
23038 swig_obj[0] = args;
23039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23040 if (!SWIG_IsOK(res1)) {
23041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23042 }
23043 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23044 {
23045 PyThreadState* __tstate = wxPyBeginAllowThreads();
23046 result = ((wxSizeEvent const *)arg1)->GetSize();
23047 wxPyEndAllowThreads(__tstate);
23048 if (PyErr_Occurred()) SWIG_fail;
23049 }
23050 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23051 return resultobj;
23052 fail:
23053 return NULL;
23054 }
23055
23056
23057 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23058 PyObject *resultobj = 0;
23059 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23060 wxRect result;
23061 void *argp1 = 0 ;
23062 int res1 = 0 ;
23063 PyObject *swig_obj[1] ;
23064
23065 if (!args) SWIG_fail;
23066 swig_obj[0] = args;
23067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23068 if (!SWIG_IsOK(res1)) {
23069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23070 }
23071 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23072 {
23073 PyThreadState* __tstate = wxPyBeginAllowThreads();
23074 result = ((wxSizeEvent const *)arg1)->GetRect();
23075 wxPyEndAllowThreads(__tstate);
23076 if (PyErr_Occurred()) SWIG_fail;
23077 }
23078 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23079 return resultobj;
23080 fail:
23081 return NULL;
23082 }
23083
23084
23085 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23086 PyObject *resultobj = 0;
23087 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23088 wxRect arg2 ;
23089 void *argp1 = 0 ;
23090 int res1 = 0 ;
23091 void *argp2 ;
23092 int res2 = 0 ;
23093 PyObject * obj0 = 0 ;
23094 PyObject * obj1 = 0 ;
23095 char * kwnames[] = {
23096 (char *) "self",(char *) "rect", NULL
23097 };
23098
23099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23101 if (!SWIG_IsOK(res1)) {
23102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23103 }
23104 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23105 {
23106 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23107 if (!SWIG_IsOK(res2)) {
23108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23109 }
23110 if (!argp2) {
23111 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23112 } else {
23113 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23114 arg2 = *temp;
23115 if (SWIG_IsNewObj(res2)) delete temp;
23116 }
23117 }
23118 {
23119 PyThreadState* __tstate = wxPyBeginAllowThreads();
23120 (arg1)->SetRect(arg2);
23121 wxPyEndAllowThreads(__tstate);
23122 if (PyErr_Occurred()) SWIG_fail;
23123 }
23124 resultobj = SWIG_Py_Void();
23125 return resultobj;
23126 fail:
23127 return NULL;
23128 }
23129
23130
23131 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23132 PyObject *resultobj = 0;
23133 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23134 wxSize arg2 ;
23135 void *argp1 = 0 ;
23136 int res1 = 0 ;
23137 void *argp2 ;
23138 int res2 = 0 ;
23139 PyObject * obj0 = 0 ;
23140 PyObject * obj1 = 0 ;
23141 char * kwnames[] = {
23142 (char *) "self",(char *) "size", NULL
23143 };
23144
23145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23147 if (!SWIG_IsOK(res1)) {
23148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23149 }
23150 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23151 {
23152 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23153 if (!SWIG_IsOK(res2)) {
23154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23155 }
23156 if (!argp2) {
23157 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23158 } else {
23159 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23160 arg2 = *temp;
23161 if (SWIG_IsNewObj(res2)) delete temp;
23162 }
23163 }
23164 {
23165 PyThreadState* __tstate = wxPyBeginAllowThreads();
23166 wxSizeEvent_SetSize(arg1,arg2);
23167 wxPyEndAllowThreads(__tstate);
23168 if (PyErr_Occurred()) SWIG_fail;
23169 }
23170 resultobj = SWIG_Py_Void();
23171 return resultobj;
23172 fail:
23173 return NULL;
23174 }
23175
23176
23177 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23178 PyObject *resultobj = 0;
23179 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23180 wxSize *arg2 = (wxSize *) 0 ;
23181 void *argp1 = 0 ;
23182 int res1 = 0 ;
23183 void *argp2 = 0 ;
23184 int res2 = 0 ;
23185 PyObject *swig_obj[2] ;
23186
23187 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23189 if (!SWIG_IsOK(res1)) {
23190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23191 }
23192 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23193 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23194 if (!SWIG_IsOK(res2)) {
23195 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23196 }
23197 arg2 = reinterpret_cast< wxSize * >(argp2);
23198 if (arg1) (arg1)->m_size = *arg2;
23199
23200 resultobj = SWIG_Py_Void();
23201 return resultobj;
23202 fail:
23203 return NULL;
23204 }
23205
23206
23207 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23208 PyObject *resultobj = 0;
23209 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23210 wxSize *result = 0 ;
23211 void *argp1 = 0 ;
23212 int res1 = 0 ;
23213 PyObject *swig_obj[1] ;
23214
23215 if (!args) SWIG_fail;
23216 swig_obj[0] = args;
23217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23218 if (!SWIG_IsOK(res1)) {
23219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23220 }
23221 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23222 result = (wxSize *)& ((arg1)->m_size);
23223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23224 return resultobj;
23225 fail:
23226 return NULL;
23227 }
23228
23229
23230 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23231 PyObject *resultobj = 0;
23232 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23233 wxRect *arg2 = (wxRect *) 0 ;
23234 void *argp1 = 0 ;
23235 int res1 = 0 ;
23236 void *argp2 = 0 ;
23237 int res2 = 0 ;
23238 PyObject *swig_obj[2] ;
23239
23240 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23242 if (!SWIG_IsOK(res1)) {
23243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23244 }
23245 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23246 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23247 if (!SWIG_IsOK(res2)) {
23248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23249 }
23250 arg2 = reinterpret_cast< wxRect * >(argp2);
23251 if (arg1) (arg1)->m_rect = *arg2;
23252
23253 resultobj = SWIG_Py_Void();
23254 return resultobj;
23255 fail:
23256 return NULL;
23257 }
23258
23259
23260 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23261 PyObject *resultobj = 0;
23262 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23263 wxRect *result = 0 ;
23264 void *argp1 = 0 ;
23265 int res1 = 0 ;
23266 PyObject *swig_obj[1] ;
23267
23268 if (!args) SWIG_fail;
23269 swig_obj[0] = args;
23270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23271 if (!SWIG_IsOK(res1)) {
23272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23273 }
23274 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23275 result = (wxRect *)& ((arg1)->m_rect);
23276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23277 return resultobj;
23278 fail:
23279 return NULL;
23280 }
23281
23282
23283 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23284 PyObject *obj;
23285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23286 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23287 return SWIG_Py_Void();
23288 }
23289
23290 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23291 return SWIG_Python_InitShadowInstance(args);
23292 }
23293
23294 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23295 PyObject *resultobj = 0;
23296 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23297 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23298 int arg2 = (int) 0 ;
23299 wxMoveEvent *result = 0 ;
23300 wxPoint temp1 ;
23301 int val2 ;
23302 int ecode2 = 0 ;
23303 PyObject * obj0 = 0 ;
23304 PyObject * obj1 = 0 ;
23305 char * kwnames[] = {
23306 (char *) "pos",(char *) "winid", NULL
23307 };
23308
23309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23310 if (obj0) {
23311 {
23312 arg1 = &temp1;
23313 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23314 }
23315 }
23316 if (obj1) {
23317 ecode2 = SWIG_AsVal_int(obj1, &val2);
23318 if (!SWIG_IsOK(ecode2)) {
23319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23320 }
23321 arg2 = static_cast< int >(val2);
23322 }
23323 {
23324 PyThreadState* __tstate = wxPyBeginAllowThreads();
23325 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23326 wxPyEndAllowThreads(__tstate);
23327 if (PyErr_Occurred()) SWIG_fail;
23328 }
23329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23330 return resultobj;
23331 fail:
23332 return NULL;
23333 }
23334
23335
23336 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23337 PyObject *resultobj = 0;
23338 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23339 wxPoint result;
23340 void *argp1 = 0 ;
23341 int res1 = 0 ;
23342 PyObject *swig_obj[1] ;
23343
23344 if (!args) SWIG_fail;
23345 swig_obj[0] = args;
23346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23347 if (!SWIG_IsOK(res1)) {
23348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23349 }
23350 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23351 {
23352 PyThreadState* __tstate = wxPyBeginAllowThreads();
23353 result = ((wxMoveEvent const *)arg1)->GetPosition();
23354 wxPyEndAllowThreads(__tstate);
23355 if (PyErr_Occurred()) SWIG_fail;
23356 }
23357 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23358 return resultobj;
23359 fail:
23360 return NULL;
23361 }
23362
23363
23364 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23365 PyObject *resultobj = 0;
23366 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23367 wxRect result;
23368 void *argp1 = 0 ;
23369 int res1 = 0 ;
23370 PyObject *swig_obj[1] ;
23371
23372 if (!args) SWIG_fail;
23373 swig_obj[0] = args;
23374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23375 if (!SWIG_IsOK(res1)) {
23376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23377 }
23378 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23379 {
23380 PyThreadState* __tstate = wxPyBeginAllowThreads();
23381 result = ((wxMoveEvent const *)arg1)->GetRect();
23382 wxPyEndAllowThreads(__tstate);
23383 if (PyErr_Occurred()) SWIG_fail;
23384 }
23385 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23386 return resultobj;
23387 fail:
23388 return NULL;
23389 }
23390
23391
23392 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23393 PyObject *resultobj = 0;
23394 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23395 wxRect *arg2 = 0 ;
23396 void *argp1 = 0 ;
23397 int res1 = 0 ;
23398 wxRect temp2 ;
23399 PyObject * obj0 = 0 ;
23400 PyObject * obj1 = 0 ;
23401 char * kwnames[] = {
23402 (char *) "self",(char *) "rect", NULL
23403 };
23404
23405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23407 if (!SWIG_IsOK(res1)) {
23408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23409 }
23410 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23411 {
23412 arg2 = &temp2;
23413 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23414 }
23415 {
23416 PyThreadState* __tstate = wxPyBeginAllowThreads();
23417 (arg1)->SetRect((wxRect const &)*arg2);
23418 wxPyEndAllowThreads(__tstate);
23419 if (PyErr_Occurred()) SWIG_fail;
23420 }
23421 resultobj = SWIG_Py_Void();
23422 return resultobj;
23423 fail:
23424 return NULL;
23425 }
23426
23427
23428 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23429 PyObject *resultobj = 0;
23430 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23431 wxPoint *arg2 = 0 ;
23432 void *argp1 = 0 ;
23433 int res1 = 0 ;
23434 wxPoint temp2 ;
23435 PyObject * obj0 = 0 ;
23436 PyObject * obj1 = 0 ;
23437 char * kwnames[] = {
23438 (char *) "self",(char *) "pos", NULL
23439 };
23440
23441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23443 if (!SWIG_IsOK(res1)) {
23444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23445 }
23446 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23447 {
23448 arg2 = &temp2;
23449 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23450 }
23451 {
23452 PyThreadState* __tstate = wxPyBeginAllowThreads();
23453 (arg1)->SetPosition((wxPoint const &)*arg2);
23454 wxPyEndAllowThreads(__tstate);
23455 if (PyErr_Occurred()) SWIG_fail;
23456 }
23457 resultobj = SWIG_Py_Void();
23458 return resultobj;
23459 fail:
23460 return NULL;
23461 }
23462
23463
23464 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23465 PyObject *obj;
23466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23467 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23468 return SWIG_Py_Void();
23469 }
23470
23471 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23472 return SWIG_Python_InitShadowInstance(args);
23473 }
23474
23475 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23476 PyObject *resultobj = 0;
23477 int arg1 = (int) 0 ;
23478 wxPaintEvent *result = 0 ;
23479 int val1 ;
23480 int ecode1 = 0 ;
23481 PyObject * obj0 = 0 ;
23482 char * kwnames[] = {
23483 (char *) "Id", NULL
23484 };
23485
23486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23487 if (obj0) {
23488 ecode1 = SWIG_AsVal_int(obj0, &val1);
23489 if (!SWIG_IsOK(ecode1)) {
23490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23491 }
23492 arg1 = static_cast< int >(val1);
23493 }
23494 {
23495 PyThreadState* __tstate = wxPyBeginAllowThreads();
23496 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23497 wxPyEndAllowThreads(__tstate);
23498 if (PyErr_Occurred()) SWIG_fail;
23499 }
23500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23501 return resultobj;
23502 fail:
23503 return NULL;
23504 }
23505
23506
23507 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23508 PyObject *obj;
23509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23510 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23511 return SWIG_Py_Void();
23512 }
23513
23514 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23515 return SWIG_Python_InitShadowInstance(args);
23516 }
23517
23518 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23519 PyObject *resultobj = 0;
23520 int arg1 = (int) 0 ;
23521 wxNcPaintEvent *result = 0 ;
23522 int val1 ;
23523 int ecode1 = 0 ;
23524 PyObject * obj0 = 0 ;
23525 char * kwnames[] = {
23526 (char *) "winid", NULL
23527 };
23528
23529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23530 if (obj0) {
23531 ecode1 = SWIG_AsVal_int(obj0, &val1);
23532 if (!SWIG_IsOK(ecode1)) {
23533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23534 }
23535 arg1 = static_cast< int >(val1);
23536 }
23537 {
23538 PyThreadState* __tstate = wxPyBeginAllowThreads();
23539 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23540 wxPyEndAllowThreads(__tstate);
23541 if (PyErr_Occurred()) SWIG_fail;
23542 }
23543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23544 return resultobj;
23545 fail:
23546 return NULL;
23547 }
23548
23549
23550 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23551 PyObject *obj;
23552 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23553 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23554 return SWIG_Py_Void();
23555 }
23556
23557 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23558 return SWIG_Python_InitShadowInstance(args);
23559 }
23560
23561 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23562 PyObject *resultobj = 0;
23563 int arg1 = (int) 0 ;
23564 wxDC *arg2 = (wxDC *) NULL ;
23565 wxEraseEvent *result = 0 ;
23566 int val1 ;
23567 int ecode1 = 0 ;
23568 void *argp2 = 0 ;
23569 int res2 = 0 ;
23570 PyObject * obj0 = 0 ;
23571 PyObject * obj1 = 0 ;
23572 char * kwnames[] = {
23573 (char *) "Id",(char *) "dc", NULL
23574 };
23575
23576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23577 if (obj0) {
23578 ecode1 = SWIG_AsVal_int(obj0, &val1);
23579 if (!SWIG_IsOK(ecode1)) {
23580 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23581 }
23582 arg1 = static_cast< int >(val1);
23583 }
23584 if (obj1) {
23585 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23586 if (!SWIG_IsOK(res2)) {
23587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23588 }
23589 arg2 = reinterpret_cast< wxDC * >(argp2);
23590 }
23591 {
23592 PyThreadState* __tstate = wxPyBeginAllowThreads();
23593 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23594 wxPyEndAllowThreads(__tstate);
23595 if (PyErr_Occurred()) SWIG_fail;
23596 }
23597 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23598 return resultobj;
23599 fail:
23600 return NULL;
23601 }
23602
23603
23604 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23605 PyObject *resultobj = 0;
23606 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23607 wxDC *result = 0 ;
23608 void *argp1 = 0 ;
23609 int res1 = 0 ;
23610 PyObject *swig_obj[1] ;
23611
23612 if (!args) SWIG_fail;
23613 swig_obj[0] = args;
23614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23615 if (!SWIG_IsOK(res1)) {
23616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23617 }
23618 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23619 {
23620 PyThreadState* __tstate = wxPyBeginAllowThreads();
23621 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23622 wxPyEndAllowThreads(__tstate);
23623 if (PyErr_Occurred()) SWIG_fail;
23624 }
23625 {
23626 resultobj = wxPyMake_wxObject(result, (bool)0);
23627 }
23628 return resultobj;
23629 fail:
23630 return NULL;
23631 }
23632
23633
23634 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23635 PyObject *obj;
23636 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23637 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23638 return SWIG_Py_Void();
23639 }
23640
23641 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23642 return SWIG_Python_InitShadowInstance(args);
23643 }
23644
23645 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23646 PyObject *resultobj = 0;
23647 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23648 int arg2 = (int) 0 ;
23649 wxFocusEvent *result = 0 ;
23650 int val1 ;
23651 int ecode1 = 0 ;
23652 int val2 ;
23653 int ecode2 = 0 ;
23654 PyObject * obj0 = 0 ;
23655 PyObject * obj1 = 0 ;
23656 char * kwnames[] = {
23657 (char *) "type",(char *) "winid", NULL
23658 };
23659
23660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23661 if (obj0) {
23662 ecode1 = SWIG_AsVal_int(obj0, &val1);
23663 if (!SWIG_IsOK(ecode1)) {
23664 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23665 }
23666 arg1 = static_cast< wxEventType >(val1);
23667 }
23668 if (obj1) {
23669 ecode2 = SWIG_AsVal_int(obj1, &val2);
23670 if (!SWIG_IsOK(ecode2)) {
23671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23672 }
23673 arg2 = static_cast< int >(val2);
23674 }
23675 {
23676 PyThreadState* __tstate = wxPyBeginAllowThreads();
23677 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23678 wxPyEndAllowThreads(__tstate);
23679 if (PyErr_Occurred()) SWIG_fail;
23680 }
23681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23682 return resultobj;
23683 fail:
23684 return NULL;
23685 }
23686
23687
23688 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23689 PyObject *resultobj = 0;
23690 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23691 wxWindow *result = 0 ;
23692 void *argp1 = 0 ;
23693 int res1 = 0 ;
23694 PyObject *swig_obj[1] ;
23695
23696 if (!args) SWIG_fail;
23697 swig_obj[0] = args;
23698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23699 if (!SWIG_IsOK(res1)) {
23700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23701 }
23702 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23703 {
23704 PyThreadState* __tstate = wxPyBeginAllowThreads();
23705 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23706 wxPyEndAllowThreads(__tstate);
23707 if (PyErr_Occurred()) SWIG_fail;
23708 }
23709 {
23710 resultobj = wxPyMake_wxObject(result, (bool)0);
23711 }
23712 return resultobj;
23713 fail:
23714 return NULL;
23715 }
23716
23717
23718 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23719 PyObject *resultobj = 0;
23720 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23721 wxWindow *arg2 = (wxWindow *) 0 ;
23722 void *argp1 = 0 ;
23723 int res1 = 0 ;
23724 void *argp2 = 0 ;
23725 int res2 = 0 ;
23726 PyObject * obj0 = 0 ;
23727 PyObject * obj1 = 0 ;
23728 char * kwnames[] = {
23729 (char *) "self",(char *) "win", NULL
23730 };
23731
23732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23734 if (!SWIG_IsOK(res1)) {
23735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23736 }
23737 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23738 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23739 if (!SWIG_IsOK(res2)) {
23740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23741 }
23742 arg2 = reinterpret_cast< wxWindow * >(argp2);
23743 {
23744 PyThreadState* __tstate = wxPyBeginAllowThreads();
23745 (arg1)->SetWindow(arg2);
23746 wxPyEndAllowThreads(__tstate);
23747 if (PyErr_Occurred()) SWIG_fail;
23748 }
23749 resultobj = SWIG_Py_Void();
23750 return resultobj;
23751 fail:
23752 return NULL;
23753 }
23754
23755
23756 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23757 PyObject *obj;
23758 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23759 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23760 return SWIG_Py_Void();
23761 }
23762
23763 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23764 return SWIG_Python_InitShadowInstance(args);
23765 }
23766
23767 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23768 PyObject *resultobj = 0;
23769 wxWindow *arg1 = (wxWindow *) NULL ;
23770 wxChildFocusEvent *result = 0 ;
23771 void *argp1 = 0 ;
23772 int res1 = 0 ;
23773 PyObject * obj0 = 0 ;
23774 char * kwnames[] = {
23775 (char *) "win", NULL
23776 };
23777
23778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23779 if (obj0) {
23780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23781 if (!SWIG_IsOK(res1)) {
23782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23783 }
23784 arg1 = reinterpret_cast< wxWindow * >(argp1);
23785 }
23786 {
23787 PyThreadState* __tstate = wxPyBeginAllowThreads();
23788 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23789 wxPyEndAllowThreads(__tstate);
23790 if (PyErr_Occurred()) SWIG_fail;
23791 }
23792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23793 return resultobj;
23794 fail:
23795 return NULL;
23796 }
23797
23798
23799 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23800 PyObject *resultobj = 0;
23801 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23802 wxWindow *result = 0 ;
23803 void *argp1 = 0 ;
23804 int res1 = 0 ;
23805 PyObject *swig_obj[1] ;
23806
23807 if (!args) SWIG_fail;
23808 swig_obj[0] = args;
23809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23810 if (!SWIG_IsOK(res1)) {
23811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23812 }
23813 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23814 {
23815 PyThreadState* __tstate = wxPyBeginAllowThreads();
23816 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23817 wxPyEndAllowThreads(__tstate);
23818 if (PyErr_Occurred()) SWIG_fail;
23819 }
23820 {
23821 resultobj = wxPyMake_wxObject(result, (bool)0);
23822 }
23823 return resultobj;
23824 fail:
23825 return NULL;
23826 }
23827
23828
23829 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23830 PyObject *obj;
23831 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23832 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23833 return SWIG_Py_Void();
23834 }
23835
23836 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23837 return SWIG_Python_InitShadowInstance(args);
23838 }
23839
23840 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23841 PyObject *resultobj = 0;
23842 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23843 bool arg2 = (bool) true ;
23844 int arg3 = (int) 0 ;
23845 wxActivateEvent *result = 0 ;
23846 int val1 ;
23847 int ecode1 = 0 ;
23848 bool val2 ;
23849 int ecode2 = 0 ;
23850 int val3 ;
23851 int ecode3 = 0 ;
23852 PyObject * obj0 = 0 ;
23853 PyObject * obj1 = 0 ;
23854 PyObject * obj2 = 0 ;
23855 char * kwnames[] = {
23856 (char *) "type",(char *) "active",(char *) "Id", NULL
23857 };
23858
23859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23860 if (obj0) {
23861 ecode1 = SWIG_AsVal_int(obj0, &val1);
23862 if (!SWIG_IsOK(ecode1)) {
23863 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23864 }
23865 arg1 = static_cast< wxEventType >(val1);
23866 }
23867 if (obj1) {
23868 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23869 if (!SWIG_IsOK(ecode2)) {
23870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23871 }
23872 arg2 = static_cast< bool >(val2);
23873 }
23874 if (obj2) {
23875 ecode3 = SWIG_AsVal_int(obj2, &val3);
23876 if (!SWIG_IsOK(ecode3)) {
23877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23878 }
23879 arg3 = static_cast< int >(val3);
23880 }
23881 {
23882 PyThreadState* __tstate = wxPyBeginAllowThreads();
23883 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23884 wxPyEndAllowThreads(__tstate);
23885 if (PyErr_Occurred()) SWIG_fail;
23886 }
23887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23888 return resultobj;
23889 fail:
23890 return NULL;
23891 }
23892
23893
23894 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23895 PyObject *resultobj = 0;
23896 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23897 bool result;
23898 void *argp1 = 0 ;
23899 int res1 = 0 ;
23900 PyObject *swig_obj[1] ;
23901
23902 if (!args) SWIG_fail;
23903 swig_obj[0] = args;
23904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23905 if (!SWIG_IsOK(res1)) {
23906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23907 }
23908 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23909 {
23910 PyThreadState* __tstate = wxPyBeginAllowThreads();
23911 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23912 wxPyEndAllowThreads(__tstate);
23913 if (PyErr_Occurred()) SWIG_fail;
23914 }
23915 {
23916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23917 }
23918 return resultobj;
23919 fail:
23920 return NULL;
23921 }
23922
23923
23924 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23925 PyObject *obj;
23926 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23927 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23928 return SWIG_Py_Void();
23929 }
23930
23931 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23932 return SWIG_Python_InitShadowInstance(args);
23933 }
23934
23935 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23936 PyObject *resultobj = 0;
23937 int arg1 = (int) 0 ;
23938 wxInitDialogEvent *result = 0 ;
23939 int val1 ;
23940 int ecode1 = 0 ;
23941 PyObject * obj0 = 0 ;
23942 char * kwnames[] = {
23943 (char *) "Id", NULL
23944 };
23945
23946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23947 if (obj0) {
23948 ecode1 = SWIG_AsVal_int(obj0, &val1);
23949 if (!SWIG_IsOK(ecode1)) {
23950 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23951 }
23952 arg1 = static_cast< int >(val1);
23953 }
23954 {
23955 PyThreadState* __tstate = wxPyBeginAllowThreads();
23956 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23957 wxPyEndAllowThreads(__tstate);
23958 if (PyErr_Occurred()) SWIG_fail;
23959 }
23960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23968 PyObject *obj;
23969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23970 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23971 return SWIG_Py_Void();
23972 }
23973
23974 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23975 return SWIG_Python_InitShadowInstance(args);
23976 }
23977
23978 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23979 PyObject *resultobj = 0;
23980 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23981 int arg2 = (int) 0 ;
23982 wxMenu *arg3 = (wxMenu *) NULL ;
23983 wxMenuEvent *result = 0 ;
23984 int val1 ;
23985 int ecode1 = 0 ;
23986 int val2 ;
23987 int ecode2 = 0 ;
23988 void *argp3 = 0 ;
23989 int res3 = 0 ;
23990 PyObject * obj0 = 0 ;
23991 PyObject * obj1 = 0 ;
23992 PyObject * obj2 = 0 ;
23993 char * kwnames[] = {
23994 (char *) "type",(char *) "winid",(char *) "menu", NULL
23995 };
23996
23997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23998 if (obj0) {
23999 ecode1 = SWIG_AsVal_int(obj0, &val1);
24000 if (!SWIG_IsOK(ecode1)) {
24001 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24002 }
24003 arg1 = static_cast< wxEventType >(val1);
24004 }
24005 if (obj1) {
24006 ecode2 = SWIG_AsVal_int(obj1, &val2);
24007 if (!SWIG_IsOK(ecode2)) {
24008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24009 }
24010 arg2 = static_cast< int >(val2);
24011 }
24012 if (obj2) {
24013 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24014 if (!SWIG_IsOK(res3)) {
24015 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24016 }
24017 arg3 = reinterpret_cast< wxMenu * >(argp3);
24018 }
24019 {
24020 PyThreadState* __tstate = wxPyBeginAllowThreads();
24021 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24022 wxPyEndAllowThreads(__tstate);
24023 if (PyErr_Occurred()) SWIG_fail;
24024 }
24025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24026 return resultobj;
24027 fail:
24028 return NULL;
24029 }
24030
24031
24032 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24033 PyObject *resultobj = 0;
24034 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24035 int result;
24036 void *argp1 = 0 ;
24037 int res1 = 0 ;
24038 PyObject *swig_obj[1] ;
24039
24040 if (!args) SWIG_fail;
24041 swig_obj[0] = args;
24042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24043 if (!SWIG_IsOK(res1)) {
24044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24045 }
24046 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24047 {
24048 PyThreadState* __tstate = wxPyBeginAllowThreads();
24049 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24050 wxPyEndAllowThreads(__tstate);
24051 if (PyErr_Occurred()) SWIG_fail;
24052 }
24053 resultobj = SWIG_From_int(static_cast< int >(result));
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24061 PyObject *resultobj = 0;
24062 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24063 bool result;
24064 void *argp1 = 0 ;
24065 int res1 = 0 ;
24066 PyObject *swig_obj[1] ;
24067
24068 if (!args) SWIG_fail;
24069 swig_obj[0] = args;
24070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24071 if (!SWIG_IsOK(res1)) {
24072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24073 }
24074 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24075 {
24076 PyThreadState* __tstate = wxPyBeginAllowThreads();
24077 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24078 wxPyEndAllowThreads(__tstate);
24079 if (PyErr_Occurred()) SWIG_fail;
24080 }
24081 {
24082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24083 }
24084 return resultobj;
24085 fail:
24086 return NULL;
24087 }
24088
24089
24090 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24091 PyObject *resultobj = 0;
24092 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24093 wxMenu *result = 0 ;
24094 void *argp1 = 0 ;
24095 int res1 = 0 ;
24096 PyObject *swig_obj[1] ;
24097
24098 if (!args) SWIG_fail;
24099 swig_obj[0] = args;
24100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24101 if (!SWIG_IsOK(res1)) {
24102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24103 }
24104 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24105 {
24106 PyThreadState* __tstate = wxPyBeginAllowThreads();
24107 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24108 wxPyEndAllowThreads(__tstate);
24109 if (PyErr_Occurred()) SWIG_fail;
24110 }
24111 {
24112 resultobj = wxPyMake_wxObject(result, (bool)0);
24113 }
24114 return resultobj;
24115 fail:
24116 return NULL;
24117 }
24118
24119
24120 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24121 PyObject *obj;
24122 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24123 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24124 return SWIG_Py_Void();
24125 }
24126
24127 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24128 return SWIG_Python_InitShadowInstance(args);
24129 }
24130
24131 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24132 PyObject *resultobj = 0;
24133 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24134 int arg2 = (int) 0 ;
24135 wxCloseEvent *result = 0 ;
24136 int val1 ;
24137 int ecode1 = 0 ;
24138 int val2 ;
24139 int ecode2 = 0 ;
24140 PyObject * obj0 = 0 ;
24141 PyObject * obj1 = 0 ;
24142 char * kwnames[] = {
24143 (char *) "type",(char *) "winid", NULL
24144 };
24145
24146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24147 if (obj0) {
24148 ecode1 = SWIG_AsVal_int(obj0, &val1);
24149 if (!SWIG_IsOK(ecode1)) {
24150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24151 }
24152 arg1 = static_cast< wxEventType >(val1);
24153 }
24154 if (obj1) {
24155 ecode2 = SWIG_AsVal_int(obj1, &val2);
24156 if (!SWIG_IsOK(ecode2)) {
24157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24158 }
24159 arg2 = static_cast< int >(val2);
24160 }
24161 {
24162 PyThreadState* __tstate = wxPyBeginAllowThreads();
24163 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24164 wxPyEndAllowThreads(__tstate);
24165 if (PyErr_Occurred()) SWIG_fail;
24166 }
24167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24168 return resultobj;
24169 fail:
24170 return NULL;
24171 }
24172
24173
24174 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24175 PyObject *resultobj = 0;
24176 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24177 bool arg2 ;
24178 void *argp1 = 0 ;
24179 int res1 = 0 ;
24180 bool val2 ;
24181 int ecode2 = 0 ;
24182 PyObject * obj0 = 0 ;
24183 PyObject * obj1 = 0 ;
24184 char * kwnames[] = {
24185 (char *) "self",(char *) "logOff", NULL
24186 };
24187
24188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24190 if (!SWIG_IsOK(res1)) {
24191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24192 }
24193 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24194 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24195 if (!SWIG_IsOK(ecode2)) {
24196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24197 }
24198 arg2 = static_cast< bool >(val2);
24199 {
24200 PyThreadState* __tstate = wxPyBeginAllowThreads();
24201 (arg1)->SetLoggingOff(arg2);
24202 wxPyEndAllowThreads(__tstate);
24203 if (PyErr_Occurred()) SWIG_fail;
24204 }
24205 resultobj = SWIG_Py_Void();
24206 return resultobj;
24207 fail:
24208 return NULL;
24209 }
24210
24211
24212 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24213 PyObject *resultobj = 0;
24214 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24215 bool result;
24216 void *argp1 = 0 ;
24217 int res1 = 0 ;
24218 PyObject *swig_obj[1] ;
24219
24220 if (!args) SWIG_fail;
24221 swig_obj[0] = args;
24222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24223 if (!SWIG_IsOK(res1)) {
24224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24225 }
24226 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24227 {
24228 PyThreadState* __tstate = wxPyBeginAllowThreads();
24229 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24230 wxPyEndAllowThreads(__tstate);
24231 if (PyErr_Occurred()) SWIG_fail;
24232 }
24233 {
24234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24235 }
24236 return resultobj;
24237 fail:
24238 return NULL;
24239 }
24240
24241
24242 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24243 PyObject *resultobj = 0;
24244 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24245 bool arg2 = (bool) true ;
24246 void *argp1 = 0 ;
24247 int res1 = 0 ;
24248 bool val2 ;
24249 int ecode2 = 0 ;
24250 PyObject * obj0 = 0 ;
24251 PyObject * obj1 = 0 ;
24252 char * kwnames[] = {
24253 (char *) "self",(char *) "veto", NULL
24254 };
24255
24256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24258 if (!SWIG_IsOK(res1)) {
24259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24260 }
24261 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24262 if (obj1) {
24263 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24264 if (!SWIG_IsOK(ecode2)) {
24265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24266 }
24267 arg2 = static_cast< bool >(val2);
24268 }
24269 {
24270 PyThreadState* __tstate = wxPyBeginAllowThreads();
24271 (arg1)->Veto(arg2);
24272 wxPyEndAllowThreads(__tstate);
24273 if (PyErr_Occurred()) SWIG_fail;
24274 }
24275 resultobj = SWIG_Py_Void();
24276 return resultobj;
24277 fail:
24278 return NULL;
24279 }
24280
24281
24282 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24283 PyObject *resultobj = 0;
24284 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24285 bool result;
24286 void *argp1 = 0 ;
24287 int res1 = 0 ;
24288 PyObject *swig_obj[1] ;
24289
24290 if (!args) SWIG_fail;
24291 swig_obj[0] = args;
24292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24293 if (!SWIG_IsOK(res1)) {
24294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24295 }
24296 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24297 {
24298 PyThreadState* __tstate = wxPyBeginAllowThreads();
24299 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24300 wxPyEndAllowThreads(__tstate);
24301 if (PyErr_Occurred()) SWIG_fail;
24302 }
24303 {
24304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24305 }
24306 return resultobj;
24307 fail:
24308 return NULL;
24309 }
24310
24311
24312 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24313 PyObject *resultobj = 0;
24314 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24315 bool arg2 ;
24316 void *argp1 = 0 ;
24317 int res1 = 0 ;
24318 bool val2 ;
24319 int ecode2 = 0 ;
24320 PyObject * obj0 = 0 ;
24321 PyObject * obj1 = 0 ;
24322 char * kwnames[] = {
24323 (char *) "self",(char *) "canVeto", NULL
24324 };
24325
24326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24328 if (!SWIG_IsOK(res1)) {
24329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24330 }
24331 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24332 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24333 if (!SWIG_IsOK(ecode2)) {
24334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24335 }
24336 arg2 = static_cast< bool >(val2);
24337 {
24338 PyThreadState* __tstate = wxPyBeginAllowThreads();
24339 (arg1)->SetCanVeto(arg2);
24340 wxPyEndAllowThreads(__tstate);
24341 if (PyErr_Occurred()) SWIG_fail;
24342 }
24343 resultobj = SWIG_Py_Void();
24344 return resultobj;
24345 fail:
24346 return NULL;
24347 }
24348
24349
24350 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24351 PyObject *resultobj = 0;
24352 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24353 bool result;
24354 void *argp1 = 0 ;
24355 int res1 = 0 ;
24356 PyObject *swig_obj[1] ;
24357
24358 if (!args) SWIG_fail;
24359 swig_obj[0] = args;
24360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24361 if (!SWIG_IsOK(res1)) {
24362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24363 }
24364 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24365 {
24366 PyThreadState* __tstate = wxPyBeginAllowThreads();
24367 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24368 wxPyEndAllowThreads(__tstate);
24369 if (PyErr_Occurred()) SWIG_fail;
24370 }
24371 {
24372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24373 }
24374 return resultobj;
24375 fail:
24376 return NULL;
24377 }
24378
24379
24380 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24381 PyObject *obj;
24382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24383 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24384 return SWIG_Py_Void();
24385 }
24386
24387 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24388 return SWIG_Python_InitShadowInstance(args);
24389 }
24390
24391 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24392 PyObject *resultobj = 0;
24393 int arg1 = (int) 0 ;
24394 bool arg2 = (bool) false ;
24395 wxShowEvent *result = 0 ;
24396 int val1 ;
24397 int ecode1 = 0 ;
24398 bool val2 ;
24399 int ecode2 = 0 ;
24400 PyObject * obj0 = 0 ;
24401 PyObject * obj1 = 0 ;
24402 char * kwnames[] = {
24403 (char *) "winid",(char *) "show", NULL
24404 };
24405
24406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24407 if (obj0) {
24408 ecode1 = SWIG_AsVal_int(obj0, &val1);
24409 if (!SWIG_IsOK(ecode1)) {
24410 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24411 }
24412 arg1 = static_cast< int >(val1);
24413 }
24414 if (obj1) {
24415 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24416 if (!SWIG_IsOK(ecode2)) {
24417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24418 }
24419 arg2 = static_cast< bool >(val2);
24420 }
24421 {
24422 PyThreadState* __tstate = wxPyBeginAllowThreads();
24423 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24424 wxPyEndAllowThreads(__tstate);
24425 if (PyErr_Occurred()) SWIG_fail;
24426 }
24427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24428 return resultobj;
24429 fail:
24430 return NULL;
24431 }
24432
24433
24434 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24435 PyObject *resultobj = 0;
24436 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24437 bool arg2 ;
24438 void *argp1 = 0 ;
24439 int res1 = 0 ;
24440 bool val2 ;
24441 int ecode2 = 0 ;
24442 PyObject * obj0 = 0 ;
24443 PyObject * obj1 = 0 ;
24444 char * kwnames[] = {
24445 (char *) "self",(char *) "show", NULL
24446 };
24447
24448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24450 if (!SWIG_IsOK(res1)) {
24451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24452 }
24453 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24454 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24455 if (!SWIG_IsOK(ecode2)) {
24456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24457 }
24458 arg2 = static_cast< bool >(val2);
24459 {
24460 PyThreadState* __tstate = wxPyBeginAllowThreads();
24461 (arg1)->SetShow(arg2);
24462 wxPyEndAllowThreads(__tstate);
24463 if (PyErr_Occurred()) SWIG_fail;
24464 }
24465 resultobj = SWIG_Py_Void();
24466 return resultobj;
24467 fail:
24468 return NULL;
24469 }
24470
24471
24472 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24473 PyObject *resultobj = 0;
24474 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24475 bool result;
24476 void *argp1 = 0 ;
24477 int res1 = 0 ;
24478 PyObject *swig_obj[1] ;
24479
24480 if (!args) SWIG_fail;
24481 swig_obj[0] = args;
24482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24483 if (!SWIG_IsOK(res1)) {
24484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24485 }
24486 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24487 {
24488 PyThreadState* __tstate = wxPyBeginAllowThreads();
24489 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24490 wxPyEndAllowThreads(__tstate);
24491 if (PyErr_Occurred()) SWIG_fail;
24492 }
24493 {
24494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24495 }
24496 return resultobj;
24497 fail:
24498 return NULL;
24499 }
24500
24501
24502 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24503 PyObject *obj;
24504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24505 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24506 return SWIG_Py_Void();
24507 }
24508
24509 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24510 return SWIG_Python_InitShadowInstance(args);
24511 }
24512
24513 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24514 PyObject *resultobj = 0;
24515 int arg1 = (int) 0 ;
24516 bool arg2 = (bool) true ;
24517 wxIconizeEvent *result = 0 ;
24518 int val1 ;
24519 int ecode1 = 0 ;
24520 bool val2 ;
24521 int ecode2 = 0 ;
24522 PyObject * obj0 = 0 ;
24523 PyObject * obj1 = 0 ;
24524 char * kwnames[] = {
24525 (char *) "id",(char *) "iconized", NULL
24526 };
24527
24528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24529 if (obj0) {
24530 ecode1 = SWIG_AsVal_int(obj0, &val1);
24531 if (!SWIG_IsOK(ecode1)) {
24532 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24533 }
24534 arg1 = static_cast< int >(val1);
24535 }
24536 if (obj1) {
24537 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24538 if (!SWIG_IsOK(ecode2)) {
24539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24540 }
24541 arg2 = static_cast< bool >(val2);
24542 }
24543 {
24544 PyThreadState* __tstate = wxPyBeginAllowThreads();
24545 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24546 wxPyEndAllowThreads(__tstate);
24547 if (PyErr_Occurred()) SWIG_fail;
24548 }
24549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24550 return resultobj;
24551 fail:
24552 return NULL;
24553 }
24554
24555
24556 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24557 PyObject *resultobj = 0;
24558 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24559 bool result;
24560 void *argp1 = 0 ;
24561 int res1 = 0 ;
24562 PyObject *swig_obj[1] ;
24563
24564 if (!args) SWIG_fail;
24565 swig_obj[0] = args;
24566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24567 if (!SWIG_IsOK(res1)) {
24568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24569 }
24570 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24571 {
24572 PyThreadState* __tstate = wxPyBeginAllowThreads();
24573 result = (bool)(arg1)->Iconized();
24574 wxPyEndAllowThreads(__tstate);
24575 if (PyErr_Occurred()) SWIG_fail;
24576 }
24577 {
24578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24579 }
24580 return resultobj;
24581 fail:
24582 return NULL;
24583 }
24584
24585
24586 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24587 PyObject *obj;
24588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24589 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24590 return SWIG_Py_Void();
24591 }
24592
24593 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24594 return SWIG_Python_InitShadowInstance(args);
24595 }
24596
24597 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24598 PyObject *resultobj = 0;
24599 int arg1 = (int) 0 ;
24600 wxMaximizeEvent *result = 0 ;
24601 int val1 ;
24602 int ecode1 = 0 ;
24603 PyObject * obj0 = 0 ;
24604 char * kwnames[] = {
24605 (char *) "id", NULL
24606 };
24607
24608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24609 if (obj0) {
24610 ecode1 = SWIG_AsVal_int(obj0, &val1);
24611 if (!SWIG_IsOK(ecode1)) {
24612 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24613 }
24614 arg1 = static_cast< int >(val1);
24615 }
24616 {
24617 PyThreadState* __tstate = wxPyBeginAllowThreads();
24618 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24619 wxPyEndAllowThreads(__tstate);
24620 if (PyErr_Occurred()) SWIG_fail;
24621 }
24622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24623 return resultobj;
24624 fail:
24625 return NULL;
24626 }
24627
24628
24629 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24630 PyObject *obj;
24631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24632 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24633 return SWIG_Py_Void();
24634 }
24635
24636 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24637 return SWIG_Python_InitShadowInstance(args);
24638 }
24639
24640 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24641 PyObject *resultobj = 0;
24642 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24643 wxPoint result;
24644 void *argp1 = 0 ;
24645 int res1 = 0 ;
24646 PyObject *swig_obj[1] ;
24647
24648 if (!args) SWIG_fail;
24649 swig_obj[0] = args;
24650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24651 if (!SWIG_IsOK(res1)) {
24652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24653 }
24654 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24655 {
24656 PyThreadState* __tstate = wxPyBeginAllowThreads();
24657 result = (arg1)->GetPosition();
24658 wxPyEndAllowThreads(__tstate);
24659 if (PyErr_Occurred()) SWIG_fail;
24660 }
24661 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24662 return resultobj;
24663 fail:
24664 return NULL;
24665 }
24666
24667
24668 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24669 PyObject *resultobj = 0;
24670 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24671 int result;
24672 void *argp1 = 0 ;
24673 int res1 = 0 ;
24674 PyObject *swig_obj[1] ;
24675
24676 if (!args) SWIG_fail;
24677 swig_obj[0] = args;
24678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24679 if (!SWIG_IsOK(res1)) {
24680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24681 }
24682 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24683 {
24684 PyThreadState* __tstate = wxPyBeginAllowThreads();
24685 result = (int)(arg1)->GetNumberOfFiles();
24686 wxPyEndAllowThreads(__tstate);
24687 if (PyErr_Occurred()) SWIG_fail;
24688 }
24689 resultobj = SWIG_From_int(static_cast< int >(result));
24690 return resultobj;
24691 fail:
24692 return NULL;
24693 }
24694
24695
24696 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24697 PyObject *resultobj = 0;
24698 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24699 PyObject *result = 0 ;
24700 void *argp1 = 0 ;
24701 int res1 = 0 ;
24702 PyObject *swig_obj[1] ;
24703
24704 if (!args) SWIG_fail;
24705 swig_obj[0] = args;
24706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24707 if (!SWIG_IsOK(res1)) {
24708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24709 }
24710 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24711 {
24712 PyThreadState* __tstate = wxPyBeginAllowThreads();
24713 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24714 wxPyEndAllowThreads(__tstate);
24715 if (PyErr_Occurred()) SWIG_fail;
24716 }
24717 resultobj = result;
24718 return resultobj;
24719 fail:
24720 return NULL;
24721 }
24722
24723
24724 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24725 PyObject *obj;
24726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24727 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24728 return SWIG_Py_Void();
24729 }
24730
24731 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24732 PyObject *resultobj = 0;
24733 int arg1 = (int) 0 ;
24734 wxUpdateUIEvent *result = 0 ;
24735 int val1 ;
24736 int ecode1 = 0 ;
24737 PyObject * obj0 = 0 ;
24738 char * kwnames[] = {
24739 (char *) "commandId", NULL
24740 };
24741
24742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24743 if (obj0) {
24744 ecode1 = SWIG_AsVal_int(obj0, &val1);
24745 if (!SWIG_IsOK(ecode1)) {
24746 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24747 }
24748 arg1 = static_cast< int >(val1);
24749 }
24750 {
24751 PyThreadState* __tstate = wxPyBeginAllowThreads();
24752 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24753 wxPyEndAllowThreads(__tstate);
24754 if (PyErr_Occurred()) SWIG_fail;
24755 }
24756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24757 return resultobj;
24758 fail:
24759 return NULL;
24760 }
24761
24762
24763 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24764 PyObject *resultobj = 0;
24765 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24766 bool result;
24767 void *argp1 = 0 ;
24768 int res1 = 0 ;
24769 PyObject *swig_obj[1] ;
24770
24771 if (!args) SWIG_fail;
24772 swig_obj[0] = args;
24773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24774 if (!SWIG_IsOK(res1)) {
24775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24776 }
24777 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24778 {
24779 PyThreadState* __tstate = wxPyBeginAllowThreads();
24780 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24781 wxPyEndAllowThreads(__tstate);
24782 if (PyErr_Occurred()) SWIG_fail;
24783 }
24784 {
24785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24786 }
24787 return resultobj;
24788 fail:
24789 return NULL;
24790 }
24791
24792
24793 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24794 PyObject *resultobj = 0;
24795 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24796 bool result;
24797 void *argp1 = 0 ;
24798 int res1 = 0 ;
24799 PyObject *swig_obj[1] ;
24800
24801 if (!args) SWIG_fail;
24802 swig_obj[0] = args;
24803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24804 if (!SWIG_IsOK(res1)) {
24805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24806 }
24807 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24808 {
24809 PyThreadState* __tstate = wxPyBeginAllowThreads();
24810 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24811 wxPyEndAllowThreads(__tstate);
24812 if (PyErr_Occurred()) SWIG_fail;
24813 }
24814 {
24815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24816 }
24817 return resultobj;
24818 fail:
24819 return NULL;
24820 }
24821
24822
24823 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24824 PyObject *resultobj = 0;
24825 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24826 bool result;
24827 void *argp1 = 0 ;
24828 int res1 = 0 ;
24829 PyObject *swig_obj[1] ;
24830
24831 if (!args) SWIG_fail;
24832 swig_obj[0] = args;
24833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24834 if (!SWIG_IsOK(res1)) {
24835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24836 }
24837 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24838 {
24839 PyThreadState* __tstate = wxPyBeginAllowThreads();
24840 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24841 wxPyEndAllowThreads(__tstate);
24842 if (PyErr_Occurred()) SWIG_fail;
24843 }
24844 {
24845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24846 }
24847 return resultobj;
24848 fail:
24849 return NULL;
24850 }
24851
24852
24853 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24854 PyObject *resultobj = 0;
24855 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24856 wxString result;
24857 void *argp1 = 0 ;
24858 int res1 = 0 ;
24859 PyObject *swig_obj[1] ;
24860
24861 if (!args) SWIG_fail;
24862 swig_obj[0] = args;
24863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24864 if (!SWIG_IsOK(res1)) {
24865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24866 }
24867 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24868 {
24869 PyThreadState* __tstate = wxPyBeginAllowThreads();
24870 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24871 wxPyEndAllowThreads(__tstate);
24872 if (PyErr_Occurred()) SWIG_fail;
24873 }
24874 {
24875 #if wxUSE_UNICODE
24876 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24877 #else
24878 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24879 #endif
24880 }
24881 return resultobj;
24882 fail:
24883 return NULL;
24884 }
24885
24886
24887 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24888 PyObject *resultobj = 0;
24889 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24890 bool result;
24891 void *argp1 = 0 ;
24892 int res1 = 0 ;
24893 PyObject *swig_obj[1] ;
24894
24895 if (!args) SWIG_fail;
24896 swig_obj[0] = args;
24897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24898 if (!SWIG_IsOK(res1)) {
24899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24900 }
24901 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24902 {
24903 PyThreadState* __tstate = wxPyBeginAllowThreads();
24904 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24905 wxPyEndAllowThreads(__tstate);
24906 if (PyErr_Occurred()) SWIG_fail;
24907 }
24908 {
24909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24910 }
24911 return resultobj;
24912 fail:
24913 return NULL;
24914 }
24915
24916
24917 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24918 PyObject *resultobj = 0;
24919 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24920 bool result;
24921 void *argp1 = 0 ;
24922 int res1 = 0 ;
24923 PyObject *swig_obj[1] ;
24924
24925 if (!args) SWIG_fail;
24926 swig_obj[0] = args;
24927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24928 if (!SWIG_IsOK(res1)) {
24929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24930 }
24931 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24932 {
24933 PyThreadState* __tstate = wxPyBeginAllowThreads();
24934 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24935 wxPyEndAllowThreads(__tstate);
24936 if (PyErr_Occurred()) SWIG_fail;
24937 }
24938 {
24939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24940 }
24941 return resultobj;
24942 fail:
24943 return NULL;
24944 }
24945
24946
24947 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24948 PyObject *resultobj = 0;
24949 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24950 bool result;
24951 void *argp1 = 0 ;
24952 int res1 = 0 ;
24953 PyObject *swig_obj[1] ;
24954
24955 if (!args) SWIG_fail;
24956 swig_obj[0] = args;
24957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24958 if (!SWIG_IsOK(res1)) {
24959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24960 }
24961 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24962 {
24963 PyThreadState* __tstate = wxPyBeginAllowThreads();
24964 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24965 wxPyEndAllowThreads(__tstate);
24966 if (PyErr_Occurred()) SWIG_fail;
24967 }
24968 {
24969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24970 }
24971 return resultobj;
24972 fail:
24973 return NULL;
24974 }
24975
24976
24977 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24978 PyObject *resultobj = 0;
24979 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24980 bool result;
24981 void *argp1 = 0 ;
24982 int res1 = 0 ;
24983 PyObject *swig_obj[1] ;
24984
24985 if (!args) SWIG_fail;
24986 swig_obj[0] = args;
24987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24988 if (!SWIG_IsOK(res1)) {
24989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24990 }
24991 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24992 {
24993 PyThreadState* __tstate = wxPyBeginAllowThreads();
24994 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24995 wxPyEndAllowThreads(__tstate);
24996 if (PyErr_Occurred()) SWIG_fail;
24997 }
24998 {
24999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25000 }
25001 return resultobj;
25002 fail:
25003 return NULL;
25004 }
25005
25006
25007 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25008 PyObject *resultobj = 0;
25009 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25010 bool arg2 ;
25011 void *argp1 = 0 ;
25012 int res1 = 0 ;
25013 bool val2 ;
25014 int ecode2 = 0 ;
25015 PyObject * obj0 = 0 ;
25016 PyObject * obj1 = 0 ;
25017 char * kwnames[] = {
25018 (char *) "self",(char *) "check", NULL
25019 };
25020
25021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25023 if (!SWIG_IsOK(res1)) {
25024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25025 }
25026 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25027 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25028 if (!SWIG_IsOK(ecode2)) {
25029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25030 }
25031 arg2 = static_cast< bool >(val2);
25032 {
25033 PyThreadState* __tstate = wxPyBeginAllowThreads();
25034 (arg1)->Check(arg2);
25035 wxPyEndAllowThreads(__tstate);
25036 if (PyErr_Occurred()) SWIG_fail;
25037 }
25038 resultobj = SWIG_Py_Void();
25039 return resultobj;
25040 fail:
25041 return NULL;
25042 }
25043
25044
25045 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25046 PyObject *resultobj = 0;
25047 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25048 bool arg2 ;
25049 void *argp1 = 0 ;
25050 int res1 = 0 ;
25051 bool val2 ;
25052 int ecode2 = 0 ;
25053 PyObject * obj0 = 0 ;
25054 PyObject * obj1 = 0 ;
25055 char * kwnames[] = {
25056 (char *) "self",(char *) "enable", NULL
25057 };
25058
25059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25061 if (!SWIG_IsOK(res1)) {
25062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25063 }
25064 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25065 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25066 if (!SWIG_IsOK(ecode2)) {
25067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25068 }
25069 arg2 = static_cast< bool >(val2);
25070 {
25071 PyThreadState* __tstate = wxPyBeginAllowThreads();
25072 (arg1)->Enable(arg2);
25073 wxPyEndAllowThreads(__tstate);
25074 if (PyErr_Occurred()) SWIG_fail;
25075 }
25076 resultobj = SWIG_Py_Void();
25077 return resultobj;
25078 fail:
25079 return NULL;
25080 }
25081
25082
25083 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25084 PyObject *resultobj = 0;
25085 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25086 bool arg2 ;
25087 void *argp1 = 0 ;
25088 int res1 = 0 ;
25089 bool val2 ;
25090 int ecode2 = 0 ;
25091 PyObject * obj0 = 0 ;
25092 PyObject * obj1 = 0 ;
25093 char * kwnames[] = {
25094 (char *) "self",(char *) "show", NULL
25095 };
25096
25097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25099 if (!SWIG_IsOK(res1)) {
25100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25101 }
25102 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25103 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25104 if (!SWIG_IsOK(ecode2)) {
25105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25106 }
25107 arg2 = static_cast< bool >(val2);
25108 {
25109 PyThreadState* __tstate = wxPyBeginAllowThreads();
25110 (arg1)->Show(arg2);
25111 wxPyEndAllowThreads(__tstate);
25112 if (PyErr_Occurred()) SWIG_fail;
25113 }
25114 resultobj = SWIG_Py_Void();
25115 return resultobj;
25116 fail:
25117 return NULL;
25118 }
25119
25120
25121 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25122 PyObject *resultobj = 0;
25123 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25124 wxString *arg2 = 0 ;
25125 void *argp1 = 0 ;
25126 int res1 = 0 ;
25127 bool temp2 = false ;
25128 PyObject * obj0 = 0 ;
25129 PyObject * obj1 = 0 ;
25130 char * kwnames[] = {
25131 (char *) "self",(char *) "text", NULL
25132 };
25133
25134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25136 if (!SWIG_IsOK(res1)) {
25137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25138 }
25139 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25140 {
25141 arg2 = wxString_in_helper(obj1);
25142 if (arg2 == NULL) SWIG_fail;
25143 temp2 = true;
25144 }
25145 {
25146 PyThreadState* __tstate = wxPyBeginAllowThreads();
25147 (arg1)->SetText((wxString const &)*arg2);
25148 wxPyEndAllowThreads(__tstate);
25149 if (PyErr_Occurred()) SWIG_fail;
25150 }
25151 resultobj = SWIG_Py_Void();
25152 {
25153 if (temp2)
25154 delete arg2;
25155 }
25156 return resultobj;
25157 fail:
25158 {
25159 if (temp2)
25160 delete arg2;
25161 }
25162 return NULL;
25163 }
25164
25165
25166 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25167 PyObject *resultobj = 0;
25168 long arg1 ;
25169 long val1 ;
25170 int ecode1 = 0 ;
25171 PyObject * obj0 = 0 ;
25172 char * kwnames[] = {
25173 (char *) "updateInterval", NULL
25174 };
25175
25176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25177 ecode1 = SWIG_AsVal_long(obj0, &val1);
25178 if (!SWIG_IsOK(ecode1)) {
25179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25180 }
25181 arg1 = static_cast< long >(val1);
25182 {
25183 PyThreadState* __tstate = wxPyBeginAllowThreads();
25184 wxUpdateUIEvent::SetUpdateInterval(arg1);
25185 wxPyEndAllowThreads(__tstate);
25186 if (PyErr_Occurred()) SWIG_fail;
25187 }
25188 resultobj = SWIG_Py_Void();
25189 return resultobj;
25190 fail:
25191 return NULL;
25192 }
25193
25194
25195 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25196 PyObject *resultobj = 0;
25197 long result;
25198
25199 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25200 {
25201 PyThreadState* __tstate = wxPyBeginAllowThreads();
25202 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25203 wxPyEndAllowThreads(__tstate);
25204 if (PyErr_Occurred()) SWIG_fail;
25205 }
25206 resultobj = SWIG_From_long(static_cast< long >(result));
25207 return resultobj;
25208 fail:
25209 return NULL;
25210 }
25211
25212
25213 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25214 PyObject *resultobj = 0;
25215 wxWindow *arg1 = (wxWindow *) 0 ;
25216 bool result;
25217 void *argp1 = 0 ;
25218 int res1 = 0 ;
25219 PyObject * obj0 = 0 ;
25220 char * kwnames[] = {
25221 (char *) "win", NULL
25222 };
25223
25224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25226 if (!SWIG_IsOK(res1)) {
25227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25228 }
25229 arg1 = reinterpret_cast< wxWindow * >(argp1);
25230 {
25231 PyThreadState* __tstate = wxPyBeginAllowThreads();
25232 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25233 wxPyEndAllowThreads(__tstate);
25234 if (PyErr_Occurred()) SWIG_fail;
25235 }
25236 {
25237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25238 }
25239 return resultobj;
25240 fail:
25241 return NULL;
25242 }
25243
25244
25245 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25246 PyObject *resultobj = 0;
25247
25248 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25249 {
25250 PyThreadState* __tstate = wxPyBeginAllowThreads();
25251 wxUpdateUIEvent::ResetUpdateTime();
25252 wxPyEndAllowThreads(__tstate);
25253 if (PyErr_Occurred()) SWIG_fail;
25254 }
25255 resultobj = SWIG_Py_Void();
25256 return resultobj;
25257 fail:
25258 return NULL;
25259 }
25260
25261
25262 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25263 PyObject *resultobj = 0;
25264 wxUpdateUIMode arg1 ;
25265 int val1 ;
25266 int ecode1 = 0 ;
25267 PyObject * obj0 = 0 ;
25268 char * kwnames[] = {
25269 (char *) "mode", NULL
25270 };
25271
25272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25273 ecode1 = SWIG_AsVal_int(obj0, &val1);
25274 if (!SWIG_IsOK(ecode1)) {
25275 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25276 }
25277 arg1 = static_cast< wxUpdateUIMode >(val1);
25278 {
25279 PyThreadState* __tstate = wxPyBeginAllowThreads();
25280 wxUpdateUIEvent::SetMode(arg1);
25281 wxPyEndAllowThreads(__tstate);
25282 if (PyErr_Occurred()) SWIG_fail;
25283 }
25284 resultobj = SWIG_Py_Void();
25285 return resultobj;
25286 fail:
25287 return NULL;
25288 }
25289
25290
25291 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25292 PyObject *resultobj = 0;
25293 wxUpdateUIMode result;
25294
25295 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25296 {
25297 PyThreadState* __tstate = wxPyBeginAllowThreads();
25298 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25299 wxPyEndAllowThreads(__tstate);
25300 if (PyErr_Occurred()) SWIG_fail;
25301 }
25302 resultobj = SWIG_From_int(static_cast< int >(result));
25303 return resultobj;
25304 fail:
25305 return NULL;
25306 }
25307
25308
25309 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25310 PyObject *obj;
25311 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25312 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25313 return SWIG_Py_Void();
25314 }
25315
25316 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25317 return SWIG_Python_InitShadowInstance(args);
25318 }
25319
25320 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25321 PyObject *resultobj = 0;
25322 wxSysColourChangedEvent *result = 0 ;
25323
25324 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25325 {
25326 PyThreadState* __tstate = wxPyBeginAllowThreads();
25327 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25328 wxPyEndAllowThreads(__tstate);
25329 if (PyErr_Occurred()) SWIG_fail;
25330 }
25331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25332 return resultobj;
25333 fail:
25334 return NULL;
25335 }
25336
25337
25338 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25339 PyObject *obj;
25340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25341 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25342 return SWIG_Py_Void();
25343 }
25344
25345 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25346 return SWIG_Python_InitShadowInstance(args);
25347 }
25348
25349 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25350 PyObject *resultobj = 0;
25351 int arg1 = (int) 0 ;
25352 wxWindow *arg2 = (wxWindow *) NULL ;
25353 wxMouseCaptureChangedEvent *result = 0 ;
25354 int val1 ;
25355 int ecode1 = 0 ;
25356 void *argp2 = 0 ;
25357 int res2 = 0 ;
25358 PyObject * obj0 = 0 ;
25359 PyObject * obj1 = 0 ;
25360 char * kwnames[] = {
25361 (char *) "winid",(char *) "gainedCapture", NULL
25362 };
25363
25364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25365 if (obj0) {
25366 ecode1 = SWIG_AsVal_int(obj0, &val1);
25367 if (!SWIG_IsOK(ecode1)) {
25368 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25369 }
25370 arg1 = static_cast< int >(val1);
25371 }
25372 if (obj1) {
25373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25374 if (!SWIG_IsOK(res2)) {
25375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25376 }
25377 arg2 = reinterpret_cast< wxWindow * >(argp2);
25378 }
25379 {
25380 PyThreadState* __tstate = wxPyBeginAllowThreads();
25381 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25382 wxPyEndAllowThreads(__tstate);
25383 if (PyErr_Occurred()) SWIG_fail;
25384 }
25385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25386 return resultobj;
25387 fail:
25388 return NULL;
25389 }
25390
25391
25392 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25393 PyObject *resultobj = 0;
25394 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25395 wxWindow *result = 0 ;
25396 void *argp1 = 0 ;
25397 int res1 = 0 ;
25398 PyObject *swig_obj[1] ;
25399
25400 if (!args) SWIG_fail;
25401 swig_obj[0] = args;
25402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25403 if (!SWIG_IsOK(res1)) {
25404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25405 }
25406 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25407 {
25408 PyThreadState* __tstate = wxPyBeginAllowThreads();
25409 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25410 wxPyEndAllowThreads(__tstate);
25411 if (PyErr_Occurred()) SWIG_fail;
25412 }
25413 {
25414 resultobj = wxPyMake_wxObject(result, (bool)0);
25415 }
25416 return resultobj;
25417 fail:
25418 return NULL;
25419 }
25420
25421
25422 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25423 PyObject *obj;
25424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25425 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25426 return SWIG_Py_Void();
25427 }
25428
25429 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25430 return SWIG_Python_InitShadowInstance(args);
25431 }
25432
25433 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25434 PyObject *resultobj = 0;
25435 wxDisplayChangedEvent *result = 0 ;
25436
25437 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25438 {
25439 PyThreadState* __tstate = wxPyBeginAllowThreads();
25440 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25441 wxPyEndAllowThreads(__tstate);
25442 if (PyErr_Occurred()) SWIG_fail;
25443 }
25444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25445 return resultobj;
25446 fail:
25447 return NULL;
25448 }
25449
25450
25451 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25452 PyObject *obj;
25453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25454 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25455 return SWIG_Py_Void();
25456 }
25457
25458 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25459 return SWIG_Python_InitShadowInstance(args);
25460 }
25461
25462 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25463 PyObject *resultobj = 0;
25464 int arg1 = (int) 0 ;
25465 wxPaletteChangedEvent *result = 0 ;
25466 int val1 ;
25467 int ecode1 = 0 ;
25468 PyObject * obj0 = 0 ;
25469 char * kwnames[] = {
25470 (char *) "id", NULL
25471 };
25472
25473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25474 if (obj0) {
25475 ecode1 = SWIG_AsVal_int(obj0, &val1);
25476 if (!SWIG_IsOK(ecode1)) {
25477 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25478 }
25479 arg1 = static_cast< int >(val1);
25480 }
25481 {
25482 PyThreadState* __tstate = wxPyBeginAllowThreads();
25483 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25484 wxPyEndAllowThreads(__tstate);
25485 if (PyErr_Occurred()) SWIG_fail;
25486 }
25487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25488 return resultobj;
25489 fail:
25490 return NULL;
25491 }
25492
25493
25494 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25495 PyObject *resultobj = 0;
25496 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25497 wxWindow *arg2 = (wxWindow *) 0 ;
25498 void *argp1 = 0 ;
25499 int res1 = 0 ;
25500 void *argp2 = 0 ;
25501 int res2 = 0 ;
25502 PyObject * obj0 = 0 ;
25503 PyObject * obj1 = 0 ;
25504 char * kwnames[] = {
25505 (char *) "self",(char *) "win", NULL
25506 };
25507
25508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25510 if (!SWIG_IsOK(res1)) {
25511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25512 }
25513 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25514 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25515 if (!SWIG_IsOK(res2)) {
25516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25517 }
25518 arg2 = reinterpret_cast< wxWindow * >(argp2);
25519 {
25520 PyThreadState* __tstate = wxPyBeginAllowThreads();
25521 (arg1)->SetChangedWindow(arg2);
25522 wxPyEndAllowThreads(__tstate);
25523 if (PyErr_Occurred()) SWIG_fail;
25524 }
25525 resultobj = SWIG_Py_Void();
25526 return resultobj;
25527 fail:
25528 return NULL;
25529 }
25530
25531
25532 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25533 PyObject *resultobj = 0;
25534 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25535 wxWindow *result = 0 ;
25536 void *argp1 = 0 ;
25537 int res1 = 0 ;
25538 PyObject *swig_obj[1] ;
25539
25540 if (!args) SWIG_fail;
25541 swig_obj[0] = args;
25542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25543 if (!SWIG_IsOK(res1)) {
25544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25545 }
25546 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25547 {
25548 PyThreadState* __tstate = wxPyBeginAllowThreads();
25549 result = (wxWindow *)(arg1)->GetChangedWindow();
25550 wxPyEndAllowThreads(__tstate);
25551 if (PyErr_Occurred()) SWIG_fail;
25552 }
25553 {
25554 resultobj = wxPyMake_wxObject(result, (bool)0);
25555 }
25556 return resultobj;
25557 fail:
25558 return NULL;
25559 }
25560
25561
25562 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25563 PyObject *obj;
25564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25565 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25566 return SWIG_Py_Void();
25567 }
25568
25569 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25570 return SWIG_Python_InitShadowInstance(args);
25571 }
25572
25573 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25574 PyObject *resultobj = 0;
25575 int arg1 = (int) 0 ;
25576 wxQueryNewPaletteEvent *result = 0 ;
25577 int val1 ;
25578 int ecode1 = 0 ;
25579 PyObject * obj0 = 0 ;
25580 char * kwnames[] = {
25581 (char *) "winid", NULL
25582 };
25583
25584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25585 if (obj0) {
25586 ecode1 = SWIG_AsVal_int(obj0, &val1);
25587 if (!SWIG_IsOK(ecode1)) {
25588 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25589 }
25590 arg1 = static_cast< int >(val1);
25591 }
25592 {
25593 PyThreadState* __tstate = wxPyBeginAllowThreads();
25594 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25595 wxPyEndAllowThreads(__tstate);
25596 if (PyErr_Occurred()) SWIG_fail;
25597 }
25598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25599 return resultobj;
25600 fail:
25601 return NULL;
25602 }
25603
25604
25605 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25606 PyObject *resultobj = 0;
25607 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25608 bool arg2 ;
25609 void *argp1 = 0 ;
25610 int res1 = 0 ;
25611 bool val2 ;
25612 int ecode2 = 0 ;
25613 PyObject * obj0 = 0 ;
25614 PyObject * obj1 = 0 ;
25615 char * kwnames[] = {
25616 (char *) "self",(char *) "realized", NULL
25617 };
25618
25619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25621 if (!SWIG_IsOK(res1)) {
25622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25623 }
25624 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25625 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25626 if (!SWIG_IsOK(ecode2)) {
25627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25628 }
25629 arg2 = static_cast< bool >(val2);
25630 {
25631 PyThreadState* __tstate = wxPyBeginAllowThreads();
25632 (arg1)->SetPaletteRealized(arg2);
25633 wxPyEndAllowThreads(__tstate);
25634 if (PyErr_Occurred()) SWIG_fail;
25635 }
25636 resultobj = SWIG_Py_Void();
25637 return resultobj;
25638 fail:
25639 return NULL;
25640 }
25641
25642
25643 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25644 PyObject *resultobj = 0;
25645 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25646 bool result;
25647 void *argp1 = 0 ;
25648 int res1 = 0 ;
25649 PyObject *swig_obj[1] ;
25650
25651 if (!args) SWIG_fail;
25652 swig_obj[0] = args;
25653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25654 if (!SWIG_IsOK(res1)) {
25655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25656 }
25657 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25658 {
25659 PyThreadState* __tstate = wxPyBeginAllowThreads();
25660 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25661 wxPyEndAllowThreads(__tstate);
25662 if (PyErr_Occurred()) SWIG_fail;
25663 }
25664 {
25665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25666 }
25667 return resultobj;
25668 fail:
25669 return NULL;
25670 }
25671
25672
25673 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25674 PyObject *obj;
25675 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25676 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25677 return SWIG_Py_Void();
25678 }
25679
25680 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25681 return SWIG_Python_InitShadowInstance(args);
25682 }
25683
25684 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25685 PyObject *resultobj = 0;
25686 wxNavigationKeyEvent *result = 0 ;
25687
25688 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25689 {
25690 PyThreadState* __tstate = wxPyBeginAllowThreads();
25691 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25692 wxPyEndAllowThreads(__tstate);
25693 if (PyErr_Occurred()) SWIG_fail;
25694 }
25695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25696 return resultobj;
25697 fail:
25698 return NULL;
25699 }
25700
25701
25702 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25703 PyObject *resultobj = 0;
25704 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25705 bool result;
25706 void *argp1 = 0 ;
25707 int res1 = 0 ;
25708 PyObject *swig_obj[1] ;
25709
25710 if (!args) SWIG_fail;
25711 swig_obj[0] = args;
25712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25713 if (!SWIG_IsOK(res1)) {
25714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25715 }
25716 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25717 {
25718 PyThreadState* __tstate = wxPyBeginAllowThreads();
25719 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25720 wxPyEndAllowThreads(__tstate);
25721 if (PyErr_Occurred()) SWIG_fail;
25722 }
25723 {
25724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25725 }
25726 return resultobj;
25727 fail:
25728 return NULL;
25729 }
25730
25731
25732 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25733 PyObject *resultobj = 0;
25734 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25735 bool arg2 ;
25736 void *argp1 = 0 ;
25737 int res1 = 0 ;
25738 bool val2 ;
25739 int ecode2 = 0 ;
25740 PyObject * obj0 = 0 ;
25741 PyObject * obj1 = 0 ;
25742 char * kwnames[] = {
25743 (char *) "self",(char *) "forward", NULL
25744 };
25745
25746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25748 if (!SWIG_IsOK(res1)) {
25749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25750 }
25751 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25752 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25753 if (!SWIG_IsOK(ecode2)) {
25754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25755 }
25756 arg2 = static_cast< bool >(val2);
25757 {
25758 PyThreadState* __tstate = wxPyBeginAllowThreads();
25759 (arg1)->SetDirection(arg2);
25760 wxPyEndAllowThreads(__tstate);
25761 if (PyErr_Occurred()) SWIG_fail;
25762 }
25763 resultobj = SWIG_Py_Void();
25764 return resultobj;
25765 fail:
25766 return NULL;
25767 }
25768
25769
25770 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25771 PyObject *resultobj = 0;
25772 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25773 bool result;
25774 void *argp1 = 0 ;
25775 int res1 = 0 ;
25776 PyObject *swig_obj[1] ;
25777
25778 if (!args) SWIG_fail;
25779 swig_obj[0] = args;
25780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25781 if (!SWIG_IsOK(res1)) {
25782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25783 }
25784 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25785 {
25786 PyThreadState* __tstate = wxPyBeginAllowThreads();
25787 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25788 wxPyEndAllowThreads(__tstate);
25789 if (PyErr_Occurred()) SWIG_fail;
25790 }
25791 {
25792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25793 }
25794 return resultobj;
25795 fail:
25796 return NULL;
25797 }
25798
25799
25800 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25801 PyObject *resultobj = 0;
25802 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25803 bool arg2 ;
25804 void *argp1 = 0 ;
25805 int res1 = 0 ;
25806 bool val2 ;
25807 int ecode2 = 0 ;
25808 PyObject * obj0 = 0 ;
25809 PyObject * obj1 = 0 ;
25810 char * kwnames[] = {
25811 (char *) "self",(char *) "ischange", NULL
25812 };
25813
25814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25816 if (!SWIG_IsOK(res1)) {
25817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25818 }
25819 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25820 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25821 if (!SWIG_IsOK(ecode2)) {
25822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25823 }
25824 arg2 = static_cast< bool >(val2);
25825 {
25826 PyThreadState* __tstate = wxPyBeginAllowThreads();
25827 (arg1)->SetWindowChange(arg2);
25828 wxPyEndAllowThreads(__tstate);
25829 if (PyErr_Occurred()) SWIG_fail;
25830 }
25831 resultobj = SWIG_Py_Void();
25832 return resultobj;
25833 fail:
25834 return NULL;
25835 }
25836
25837
25838 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25839 PyObject *resultobj = 0;
25840 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25841 bool result;
25842 void *argp1 = 0 ;
25843 int res1 = 0 ;
25844 PyObject *swig_obj[1] ;
25845
25846 if (!args) SWIG_fail;
25847 swig_obj[0] = args;
25848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25849 if (!SWIG_IsOK(res1)) {
25850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25851 }
25852 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25853 {
25854 PyThreadState* __tstate = wxPyBeginAllowThreads();
25855 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25856 wxPyEndAllowThreads(__tstate);
25857 if (PyErr_Occurred()) SWIG_fail;
25858 }
25859 {
25860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25861 }
25862 return resultobj;
25863 fail:
25864 return NULL;
25865 }
25866
25867
25868 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25869 PyObject *resultobj = 0;
25870 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25871 bool arg2 ;
25872 void *argp1 = 0 ;
25873 int res1 = 0 ;
25874 bool val2 ;
25875 int ecode2 = 0 ;
25876 PyObject * obj0 = 0 ;
25877 PyObject * obj1 = 0 ;
25878 char * kwnames[] = {
25879 (char *) "self",(char *) "bIs", NULL
25880 };
25881
25882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25884 if (!SWIG_IsOK(res1)) {
25885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25886 }
25887 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25888 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25889 if (!SWIG_IsOK(ecode2)) {
25890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25891 }
25892 arg2 = static_cast< bool >(val2);
25893 {
25894 PyThreadState* __tstate = wxPyBeginAllowThreads();
25895 (arg1)->SetFromTab(arg2);
25896 wxPyEndAllowThreads(__tstate);
25897 if (PyErr_Occurred()) SWIG_fail;
25898 }
25899 resultobj = SWIG_Py_Void();
25900 return resultobj;
25901 fail:
25902 return NULL;
25903 }
25904
25905
25906 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25907 PyObject *resultobj = 0;
25908 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25909 long arg2 ;
25910 void *argp1 = 0 ;
25911 int res1 = 0 ;
25912 long val2 ;
25913 int ecode2 = 0 ;
25914 PyObject * obj0 = 0 ;
25915 PyObject * obj1 = 0 ;
25916 char * kwnames[] = {
25917 (char *) "self",(char *) "flags", NULL
25918 };
25919
25920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25922 if (!SWIG_IsOK(res1)) {
25923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25924 }
25925 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25926 ecode2 = SWIG_AsVal_long(obj1, &val2);
25927 if (!SWIG_IsOK(ecode2)) {
25928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25929 }
25930 arg2 = static_cast< long >(val2);
25931 {
25932 PyThreadState* __tstate = wxPyBeginAllowThreads();
25933 (arg1)->SetFlags(arg2);
25934 wxPyEndAllowThreads(__tstate);
25935 if (PyErr_Occurred()) SWIG_fail;
25936 }
25937 resultobj = SWIG_Py_Void();
25938 return resultobj;
25939 fail:
25940 return NULL;
25941 }
25942
25943
25944 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25945 PyObject *resultobj = 0;
25946 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25947 wxWindow *result = 0 ;
25948 void *argp1 = 0 ;
25949 int res1 = 0 ;
25950 PyObject *swig_obj[1] ;
25951
25952 if (!args) SWIG_fail;
25953 swig_obj[0] = args;
25954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25955 if (!SWIG_IsOK(res1)) {
25956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25957 }
25958 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25959 {
25960 PyThreadState* __tstate = wxPyBeginAllowThreads();
25961 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25962 wxPyEndAllowThreads(__tstate);
25963 if (PyErr_Occurred()) SWIG_fail;
25964 }
25965 {
25966 resultobj = wxPyMake_wxObject(result, (bool)0);
25967 }
25968 return resultobj;
25969 fail:
25970 return NULL;
25971 }
25972
25973
25974 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25975 PyObject *resultobj = 0;
25976 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25977 wxWindow *arg2 = (wxWindow *) 0 ;
25978 void *argp1 = 0 ;
25979 int res1 = 0 ;
25980 void *argp2 = 0 ;
25981 int res2 = 0 ;
25982 PyObject * obj0 = 0 ;
25983 PyObject * obj1 = 0 ;
25984 char * kwnames[] = {
25985 (char *) "self",(char *) "win", NULL
25986 };
25987
25988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25990 if (!SWIG_IsOK(res1)) {
25991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25992 }
25993 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25994 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25995 if (!SWIG_IsOK(res2)) {
25996 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25997 }
25998 arg2 = reinterpret_cast< wxWindow * >(argp2);
25999 {
26000 PyThreadState* __tstate = wxPyBeginAllowThreads();
26001 (arg1)->SetCurrentFocus(arg2);
26002 wxPyEndAllowThreads(__tstate);
26003 if (PyErr_Occurred()) SWIG_fail;
26004 }
26005 resultobj = SWIG_Py_Void();
26006 return resultobj;
26007 fail:
26008 return NULL;
26009 }
26010
26011
26012 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26013 PyObject *obj;
26014 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26015 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26016 return SWIG_Py_Void();
26017 }
26018
26019 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26020 return SWIG_Python_InitShadowInstance(args);
26021 }
26022
26023 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26024 PyObject *resultobj = 0;
26025 wxWindow *arg1 = (wxWindow *) NULL ;
26026 wxWindowCreateEvent *result = 0 ;
26027 void *argp1 = 0 ;
26028 int res1 = 0 ;
26029 PyObject * obj0 = 0 ;
26030 char * kwnames[] = {
26031 (char *) "win", NULL
26032 };
26033
26034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26035 if (obj0) {
26036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26037 if (!SWIG_IsOK(res1)) {
26038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26039 }
26040 arg1 = reinterpret_cast< wxWindow * >(argp1);
26041 }
26042 {
26043 PyThreadState* __tstate = wxPyBeginAllowThreads();
26044 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26045 wxPyEndAllowThreads(__tstate);
26046 if (PyErr_Occurred()) SWIG_fail;
26047 }
26048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26049 return resultobj;
26050 fail:
26051 return NULL;
26052 }
26053
26054
26055 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26056 PyObject *resultobj = 0;
26057 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26058 wxWindow *result = 0 ;
26059 void *argp1 = 0 ;
26060 int res1 = 0 ;
26061 PyObject *swig_obj[1] ;
26062
26063 if (!args) SWIG_fail;
26064 swig_obj[0] = args;
26065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26066 if (!SWIG_IsOK(res1)) {
26067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26068 }
26069 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26070 {
26071 PyThreadState* __tstate = wxPyBeginAllowThreads();
26072 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26073 wxPyEndAllowThreads(__tstate);
26074 if (PyErr_Occurred()) SWIG_fail;
26075 }
26076 {
26077 resultobj = wxPyMake_wxObject(result, (bool)0);
26078 }
26079 return resultobj;
26080 fail:
26081 return NULL;
26082 }
26083
26084
26085 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26086 PyObject *obj;
26087 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26088 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26089 return SWIG_Py_Void();
26090 }
26091
26092 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26093 return SWIG_Python_InitShadowInstance(args);
26094 }
26095
26096 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26097 PyObject *resultobj = 0;
26098 wxWindow *arg1 = (wxWindow *) NULL ;
26099 wxWindowDestroyEvent *result = 0 ;
26100 void *argp1 = 0 ;
26101 int res1 = 0 ;
26102 PyObject * obj0 = 0 ;
26103 char * kwnames[] = {
26104 (char *) "win", NULL
26105 };
26106
26107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26108 if (obj0) {
26109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26110 if (!SWIG_IsOK(res1)) {
26111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26112 }
26113 arg1 = reinterpret_cast< wxWindow * >(argp1);
26114 }
26115 {
26116 PyThreadState* __tstate = wxPyBeginAllowThreads();
26117 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26118 wxPyEndAllowThreads(__tstate);
26119 if (PyErr_Occurred()) SWIG_fail;
26120 }
26121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26122 return resultobj;
26123 fail:
26124 return NULL;
26125 }
26126
26127
26128 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26129 PyObject *resultobj = 0;
26130 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26131 wxWindow *result = 0 ;
26132 void *argp1 = 0 ;
26133 int res1 = 0 ;
26134 PyObject *swig_obj[1] ;
26135
26136 if (!args) SWIG_fail;
26137 swig_obj[0] = args;
26138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26139 if (!SWIG_IsOK(res1)) {
26140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26141 }
26142 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26143 {
26144 PyThreadState* __tstate = wxPyBeginAllowThreads();
26145 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26146 wxPyEndAllowThreads(__tstate);
26147 if (PyErr_Occurred()) SWIG_fail;
26148 }
26149 {
26150 resultobj = wxPyMake_wxObject(result, (bool)0);
26151 }
26152 return resultobj;
26153 fail:
26154 return NULL;
26155 }
26156
26157
26158 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26159 PyObject *obj;
26160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26161 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26162 return SWIG_Py_Void();
26163 }
26164
26165 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26166 return SWIG_Python_InitShadowInstance(args);
26167 }
26168
26169 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26170 PyObject *resultobj = 0;
26171 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26172 int arg2 = (int) 0 ;
26173 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26174 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26175 wxContextMenuEvent *result = 0 ;
26176 int val1 ;
26177 int ecode1 = 0 ;
26178 int val2 ;
26179 int ecode2 = 0 ;
26180 wxPoint temp3 ;
26181 PyObject * obj0 = 0 ;
26182 PyObject * obj1 = 0 ;
26183 PyObject * obj2 = 0 ;
26184 char * kwnames[] = {
26185 (char *) "type",(char *) "winid",(char *) "pt", NULL
26186 };
26187
26188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26189 if (obj0) {
26190 ecode1 = SWIG_AsVal_int(obj0, &val1);
26191 if (!SWIG_IsOK(ecode1)) {
26192 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26193 }
26194 arg1 = static_cast< wxEventType >(val1);
26195 }
26196 if (obj1) {
26197 ecode2 = SWIG_AsVal_int(obj1, &val2);
26198 if (!SWIG_IsOK(ecode2)) {
26199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26200 }
26201 arg2 = static_cast< int >(val2);
26202 }
26203 if (obj2) {
26204 {
26205 arg3 = &temp3;
26206 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26207 }
26208 }
26209 {
26210 PyThreadState* __tstate = wxPyBeginAllowThreads();
26211 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26212 wxPyEndAllowThreads(__tstate);
26213 if (PyErr_Occurred()) SWIG_fail;
26214 }
26215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26216 return resultobj;
26217 fail:
26218 return NULL;
26219 }
26220
26221
26222 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26223 PyObject *resultobj = 0;
26224 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26225 wxPoint *result = 0 ;
26226 void *argp1 = 0 ;
26227 int res1 = 0 ;
26228 PyObject *swig_obj[1] ;
26229
26230 if (!args) SWIG_fail;
26231 swig_obj[0] = args;
26232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26233 if (!SWIG_IsOK(res1)) {
26234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26235 }
26236 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26237 {
26238 PyThreadState* __tstate = wxPyBeginAllowThreads();
26239 {
26240 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26241 result = (wxPoint *) &_result_ref;
26242 }
26243 wxPyEndAllowThreads(__tstate);
26244 if (PyErr_Occurred()) SWIG_fail;
26245 }
26246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26247 return resultobj;
26248 fail:
26249 return NULL;
26250 }
26251
26252
26253 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26254 PyObject *resultobj = 0;
26255 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26256 wxPoint *arg2 = 0 ;
26257 void *argp1 = 0 ;
26258 int res1 = 0 ;
26259 wxPoint temp2 ;
26260 PyObject * obj0 = 0 ;
26261 PyObject * obj1 = 0 ;
26262 char * kwnames[] = {
26263 (char *) "self",(char *) "pos", NULL
26264 };
26265
26266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26268 if (!SWIG_IsOK(res1)) {
26269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26270 }
26271 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26272 {
26273 arg2 = &temp2;
26274 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26275 }
26276 {
26277 PyThreadState* __tstate = wxPyBeginAllowThreads();
26278 (arg1)->SetPosition((wxPoint const &)*arg2);
26279 wxPyEndAllowThreads(__tstate);
26280 if (PyErr_Occurred()) SWIG_fail;
26281 }
26282 resultobj = SWIG_Py_Void();
26283 return resultobj;
26284 fail:
26285 return NULL;
26286 }
26287
26288
26289 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26290 PyObject *obj;
26291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26292 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26293 return SWIG_Py_Void();
26294 }
26295
26296 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26297 return SWIG_Python_InitShadowInstance(args);
26298 }
26299
26300 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26301 PyObject *resultobj = 0;
26302 wxIdleEvent *result = 0 ;
26303
26304 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26305 {
26306 PyThreadState* __tstate = wxPyBeginAllowThreads();
26307 result = (wxIdleEvent *)new wxIdleEvent();
26308 wxPyEndAllowThreads(__tstate);
26309 if (PyErr_Occurred()) SWIG_fail;
26310 }
26311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26312 return resultobj;
26313 fail:
26314 return NULL;
26315 }
26316
26317
26318 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26319 PyObject *resultobj = 0;
26320 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26321 bool arg2 = (bool) true ;
26322 void *argp1 = 0 ;
26323 int res1 = 0 ;
26324 bool val2 ;
26325 int ecode2 = 0 ;
26326 PyObject * obj0 = 0 ;
26327 PyObject * obj1 = 0 ;
26328 char * kwnames[] = {
26329 (char *) "self",(char *) "needMore", NULL
26330 };
26331
26332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26334 if (!SWIG_IsOK(res1)) {
26335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26336 }
26337 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26338 if (obj1) {
26339 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26340 if (!SWIG_IsOK(ecode2)) {
26341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26342 }
26343 arg2 = static_cast< bool >(val2);
26344 }
26345 {
26346 PyThreadState* __tstate = wxPyBeginAllowThreads();
26347 (arg1)->RequestMore(arg2);
26348 wxPyEndAllowThreads(__tstate);
26349 if (PyErr_Occurred()) SWIG_fail;
26350 }
26351 resultobj = SWIG_Py_Void();
26352 return resultobj;
26353 fail:
26354 return NULL;
26355 }
26356
26357
26358 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26359 PyObject *resultobj = 0;
26360 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26361 bool result;
26362 void *argp1 = 0 ;
26363 int res1 = 0 ;
26364 PyObject *swig_obj[1] ;
26365
26366 if (!args) SWIG_fail;
26367 swig_obj[0] = args;
26368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26369 if (!SWIG_IsOK(res1)) {
26370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26371 }
26372 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26373 {
26374 PyThreadState* __tstate = wxPyBeginAllowThreads();
26375 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26376 wxPyEndAllowThreads(__tstate);
26377 if (PyErr_Occurred()) SWIG_fail;
26378 }
26379 {
26380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26381 }
26382 return resultobj;
26383 fail:
26384 return NULL;
26385 }
26386
26387
26388 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26389 PyObject *resultobj = 0;
26390 wxIdleMode arg1 ;
26391 int val1 ;
26392 int ecode1 = 0 ;
26393 PyObject * obj0 = 0 ;
26394 char * kwnames[] = {
26395 (char *) "mode", NULL
26396 };
26397
26398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26399 ecode1 = SWIG_AsVal_int(obj0, &val1);
26400 if (!SWIG_IsOK(ecode1)) {
26401 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26402 }
26403 arg1 = static_cast< wxIdleMode >(val1);
26404 {
26405 PyThreadState* __tstate = wxPyBeginAllowThreads();
26406 wxIdleEvent::SetMode(arg1);
26407 wxPyEndAllowThreads(__tstate);
26408 if (PyErr_Occurred()) SWIG_fail;
26409 }
26410 resultobj = SWIG_Py_Void();
26411 return resultobj;
26412 fail:
26413 return NULL;
26414 }
26415
26416
26417 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26418 PyObject *resultobj = 0;
26419 wxIdleMode result;
26420
26421 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26422 {
26423 PyThreadState* __tstate = wxPyBeginAllowThreads();
26424 result = (wxIdleMode)wxIdleEvent::GetMode();
26425 wxPyEndAllowThreads(__tstate);
26426 if (PyErr_Occurred()) SWIG_fail;
26427 }
26428 resultobj = SWIG_From_int(static_cast< int >(result));
26429 return resultobj;
26430 fail:
26431 return NULL;
26432 }
26433
26434
26435 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26436 PyObject *resultobj = 0;
26437 wxWindow *arg1 = (wxWindow *) 0 ;
26438 bool result;
26439 void *argp1 = 0 ;
26440 int res1 = 0 ;
26441 PyObject * obj0 = 0 ;
26442 char * kwnames[] = {
26443 (char *) "win", NULL
26444 };
26445
26446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26448 if (!SWIG_IsOK(res1)) {
26449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26450 }
26451 arg1 = reinterpret_cast< wxWindow * >(argp1);
26452 {
26453 PyThreadState* __tstate = wxPyBeginAllowThreads();
26454 result = (bool)wxIdleEvent::CanSend(arg1);
26455 wxPyEndAllowThreads(__tstate);
26456 if (PyErr_Occurred()) SWIG_fail;
26457 }
26458 {
26459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26460 }
26461 return resultobj;
26462 fail:
26463 return NULL;
26464 }
26465
26466
26467 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26468 PyObject *obj;
26469 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26470 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26471 return SWIG_Py_Void();
26472 }
26473
26474 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26475 return SWIG_Python_InitShadowInstance(args);
26476 }
26477
26478 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26479 PyObject *resultobj = 0;
26480 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26481 int arg2 = (int) 0 ;
26482 wxClipboardTextEvent *result = 0 ;
26483 int val1 ;
26484 int ecode1 = 0 ;
26485 int val2 ;
26486 int ecode2 = 0 ;
26487 PyObject * obj0 = 0 ;
26488 PyObject * obj1 = 0 ;
26489 char * kwnames[] = {
26490 (char *) "type",(char *) "winid", NULL
26491 };
26492
26493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26494 if (obj0) {
26495 ecode1 = SWIG_AsVal_int(obj0, &val1);
26496 if (!SWIG_IsOK(ecode1)) {
26497 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26498 }
26499 arg1 = static_cast< wxEventType >(val1);
26500 }
26501 if (obj1) {
26502 ecode2 = SWIG_AsVal_int(obj1, &val2);
26503 if (!SWIG_IsOK(ecode2)) {
26504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26505 }
26506 arg2 = static_cast< int >(val2);
26507 }
26508 {
26509 PyThreadState* __tstate = wxPyBeginAllowThreads();
26510 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26511 wxPyEndAllowThreads(__tstate);
26512 if (PyErr_Occurred()) SWIG_fail;
26513 }
26514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26515 return resultobj;
26516 fail:
26517 return NULL;
26518 }
26519
26520
26521 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26522 PyObject *obj;
26523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26524 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26525 return SWIG_Py_Void();
26526 }
26527
26528 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26529 return SWIG_Python_InitShadowInstance(args);
26530 }
26531
26532 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26533 PyObject *resultobj = 0;
26534 int arg1 = (int) 0 ;
26535 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26536 wxPyEvent *result = 0 ;
26537 int val1 ;
26538 int ecode1 = 0 ;
26539 int val2 ;
26540 int ecode2 = 0 ;
26541 PyObject * obj0 = 0 ;
26542 PyObject * obj1 = 0 ;
26543 char * kwnames[] = {
26544 (char *) "winid",(char *) "eventType", NULL
26545 };
26546
26547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26548 if (obj0) {
26549 ecode1 = SWIG_AsVal_int(obj0, &val1);
26550 if (!SWIG_IsOK(ecode1)) {
26551 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26552 }
26553 arg1 = static_cast< int >(val1);
26554 }
26555 if (obj1) {
26556 ecode2 = SWIG_AsVal_int(obj1, &val2);
26557 if (!SWIG_IsOK(ecode2)) {
26558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26559 }
26560 arg2 = static_cast< wxEventType >(val2);
26561 }
26562 {
26563 PyThreadState* __tstate = wxPyBeginAllowThreads();
26564 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26565 wxPyEndAllowThreads(__tstate);
26566 if (PyErr_Occurred()) SWIG_fail;
26567 }
26568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26569 return resultobj;
26570 fail:
26571 return NULL;
26572 }
26573
26574
26575 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26576 PyObject *resultobj = 0;
26577 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26578 void *argp1 = 0 ;
26579 int res1 = 0 ;
26580 PyObject *swig_obj[1] ;
26581
26582 if (!args) SWIG_fail;
26583 swig_obj[0] = args;
26584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26585 if (!SWIG_IsOK(res1)) {
26586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26587 }
26588 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26589 {
26590 PyThreadState* __tstate = wxPyBeginAllowThreads();
26591 delete arg1;
26592
26593 wxPyEndAllowThreads(__tstate);
26594 if (PyErr_Occurred()) SWIG_fail;
26595 }
26596 resultobj = SWIG_Py_Void();
26597 return resultobj;
26598 fail:
26599 return NULL;
26600 }
26601
26602
26603 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26604 PyObject *resultobj = 0;
26605 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26606 PyObject *arg2 = (PyObject *) 0 ;
26607 void *argp1 = 0 ;
26608 int res1 = 0 ;
26609 PyObject * obj0 = 0 ;
26610 PyObject * obj1 = 0 ;
26611 char * kwnames[] = {
26612 (char *) "self",(char *) "self", NULL
26613 };
26614
26615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26617 if (!SWIG_IsOK(res1)) {
26618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26619 }
26620 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26621 arg2 = obj1;
26622 {
26623 PyThreadState* __tstate = wxPyBeginAllowThreads();
26624 (arg1)->SetSelf(arg2);
26625 wxPyEndAllowThreads(__tstate);
26626 if (PyErr_Occurred()) SWIG_fail;
26627 }
26628 resultobj = SWIG_Py_Void();
26629 return resultobj;
26630 fail:
26631 return NULL;
26632 }
26633
26634
26635 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26636 PyObject *resultobj = 0;
26637 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26638 PyObject *result = 0 ;
26639 void *argp1 = 0 ;
26640 int res1 = 0 ;
26641 PyObject *swig_obj[1] ;
26642
26643 if (!args) SWIG_fail;
26644 swig_obj[0] = args;
26645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26646 if (!SWIG_IsOK(res1)) {
26647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26648 }
26649 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26650 {
26651 PyThreadState* __tstate = wxPyBeginAllowThreads();
26652 result = (PyObject *)(arg1)->GetSelf();
26653 wxPyEndAllowThreads(__tstate);
26654 if (PyErr_Occurred()) SWIG_fail;
26655 }
26656 resultobj = result;
26657 return resultobj;
26658 fail:
26659 return NULL;
26660 }
26661
26662
26663 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26664 PyObject *obj;
26665 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26666 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26667 return SWIG_Py_Void();
26668 }
26669
26670 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26671 return SWIG_Python_InitShadowInstance(args);
26672 }
26673
26674 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26675 PyObject *resultobj = 0;
26676 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26677 int arg2 = (int) 0 ;
26678 wxPyCommandEvent *result = 0 ;
26679 int val1 ;
26680 int ecode1 = 0 ;
26681 int val2 ;
26682 int ecode2 = 0 ;
26683 PyObject * obj0 = 0 ;
26684 PyObject * obj1 = 0 ;
26685 char * kwnames[] = {
26686 (char *) "eventType",(char *) "id", NULL
26687 };
26688
26689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26690 if (obj0) {
26691 ecode1 = SWIG_AsVal_int(obj0, &val1);
26692 if (!SWIG_IsOK(ecode1)) {
26693 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26694 }
26695 arg1 = static_cast< wxEventType >(val1);
26696 }
26697 if (obj1) {
26698 ecode2 = SWIG_AsVal_int(obj1, &val2);
26699 if (!SWIG_IsOK(ecode2)) {
26700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26701 }
26702 arg2 = static_cast< int >(val2);
26703 }
26704 {
26705 PyThreadState* __tstate = wxPyBeginAllowThreads();
26706 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26707 wxPyEndAllowThreads(__tstate);
26708 if (PyErr_Occurred()) SWIG_fail;
26709 }
26710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26711 return resultobj;
26712 fail:
26713 return NULL;
26714 }
26715
26716
26717 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26718 PyObject *resultobj = 0;
26719 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26720 void *argp1 = 0 ;
26721 int res1 = 0 ;
26722 PyObject *swig_obj[1] ;
26723
26724 if (!args) SWIG_fail;
26725 swig_obj[0] = args;
26726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26727 if (!SWIG_IsOK(res1)) {
26728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26729 }
26730 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26731 {
26732 PyThreadState* __tstate = wxPyBeginAllowThreads();
26733 delete arg1;
26734
26735 wxPyEndAllowThreads(__tstate);
26736 if (PyErr_Occurred()) SWIG_fail;
26737 }
26738 resultobj = SWIG_Py_Void();
26739 return resultobj;
26740 fail:
26741 return NULL;
26742 }
26743
26744
26745 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26746 PyObject *resultobj = 0;
26747 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26748 PyObject *arg2 = (PyObject *) 0 ;
26749 void *argp1 = 0 ;
26750 int res1 = 0 ;
26751 PyObject * obj0 = 0 ;
26752 PyObject * obj1 = 0 ;
26753 char * kwnames[] = {
26754 (char *) "self",(char *) "self", NULL
26755 };
26756
26757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26759 if (!SWIG_IsOK(res1)) {
26760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26761 }
26762 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26763 arg2 = obj1;
26764 {
26765 PyThreadState* __tstate = wxPyBeginAllowThreads();
26766 (arg1)->SetSelf(arg2);
26767 wxPyEndAllowThreads(__tstate);
26768 if (PyErr_Occurred()) SWIG_fail;
26769 }
26770 resultobj = SWIG_Py_Void();
26771 return resultobj;
26772 fail:
26773 return NULL;
26774 }
26775
26776
26777 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26778 PyObject *resultobj = 0;
26779 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26780 PyObject *result = 0 ;
26781 void *argp1 = 0 ;
26782 int res1 = 0 ;
26783 PyObject *swig_obj[1] ;
26784
26785 if (!args) SWIG_fail;
26786 swig_obj[0] = args;
26787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26788 if (!SWIG_IsOK(res1)) {
26789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26790 }
26791 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26792 {
26793 PyThreadState* __tstate = wxPyBeginAllowThreads();
26794 result = (PyObject *)(arg1)->GetSelf();
26795 wxPyEndAllowThreads(__tstate);
26796 if (PyErr_Occurred()) SWIG_fail;
26797 }
26798 resultobj = result;
26799 return resultobj;
26800 fail:
26801 return NULL;
26802 }
26803
26804
26805 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26806 PyObject *obj;
26807 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26808 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26809 return SWIG_Py_Void();
26810 }
26811
26812 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26813 return SWIG_Python_InitShadowInstance(args);
26814 }
26815
26816 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26817 PyObject *resultobj = 0;
26818 wxWindow *arg1 = (wxWindow *) 0 ;
26819 wxDateTime *arg2 = 0 ;
26820 wxEventType arg3 ;
26821 wxDateEvent *result = 0 ;
26822 void *argp1 = 0 ;
26823 int res1 = 0 ;
26824 void *argp2 = 0 ;
26825 int res2 = 0 ;
26826 int val3 ;
26827 int ecode3 = 0 ;
26828 PyObject * obj0 = 0 ;
26829 PyObject * obj1 = 0 ;
26830 PyObject * obj2 = 0 ;
26831 char * kwnames[] = {
26832 (char *) "win",(char *) "dt",(char *) "type", NULL
26833 };
26834
26835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26837 if (!SWIG_IsOK(res1)) {
26838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26839 }
26840 arg1 = reinterpret_cast< wxWindow * >(argp1);
26841 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26842 if (!SWIG_IsOK(res2)) {
26843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26844 }
26845 if (!argp2) {
26846 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26847 }
26848 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26849 ecode3 = SWIG_AsVal_int(obj2, &val3);
26850 if (!SWIG_IsOK(ecode3)) {
26851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26852 }
26853 arg3 = static_cast< wxEventType >(val3);
26854 {
26855 PyThreadState* __tstate = wxPyBeginAllowThreads();
26856 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26857 wxPyEndAllowThreads(__tstate);
26858 if (PyErr_Occurred()) SWIG_fail;
26859 }
26860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26861 return resultobj;
26862 fail:
26863 return NULL;
26864 }
26865
26866
26867 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26868 PyObject *resultobj = 0;
26869 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26870 wxDateTime *result = 0 ;
26871 void *argp1 = 0 ;
26872 int res1 = 0 ;
26873 PyObject *swig_obj[1] ;
26874
26875 if (!args) SWIG_fail;
26876 swig_obj[0] = args;
26877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26878 if (!SWIG_IsOK(res1)) {
26879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26880 }
26881 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26882 {
26883 PyThreadState* __tstate = wxPyBeginAllowThreads();
26884 {
26885 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26886 result = (wxDateTime *) &_result_ref;
26887 }
26888 wxPyEndAllowThreads(__tstate);
26889 if (PyErr_Occurred()) SWIG_fail;
26890 }
26891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26892 return resultobj;
26893 fail:
26894 return NULL;
26895 }
26896
26897
26898 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26899 PyObject *resultobj = 0;
26900 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26901 wxDateTime *arg2 = 0 ;
26902 void *argp1 = 0 ;
26903 int res1 = 0 ;
26904 void *argp2 = 0 ;
26905 int res2 = 0 ;
26906 PyObject * obj0 = 0 ;
26907 PyObject * obj1 = 0 ;
26908 char * kwnames[] = {
26909 (char *) "self",(char *) "date", NULL
26910 };
26911
26912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26914 if (!SWIG_IsOK(res1)) {
26915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26916 }
26917 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26918 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26919 if (!SWIG_IsOK(res2)) {
26920 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26921 }
26922 if (!argp2) {
26923 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26924 }
26925 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26926 {
26927 PyThreadState* __tstate = wxPyBeginAllowThreads();
26928 (arg1)->SetDate((wxDateTime const &)*arg2);
26929 wxPyEndAllowThreads(__tstate);
26930 if (PyErr_Occurred()) SWIG_fail;
26931 }
26932 resultobj = SWIG_Py_Void();
26933 return resultobj;
26934 fail:
26935 return NULL;
26936 }
26937
26938
26939 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26940 PyObject *obj;
26941 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26942 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26943 return SWIG_Py_Void();
26944 }
26945
26946 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26947 return SWIG_Python_InitShadowInstance(args);
26948 }
26949
26950 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26951 PyObject *resultobj = 0;
26952 wxPyApp *result = 0 ;
26953
26954 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26955 {
26956 PyThreadState* __tstate = wxPyBeginAllowThreads();
26957 result = (wxPyApp *)new_wxPyApp();
26958 wxPyEndAllowThreads(__tstate);
26959 if (PyErr_Occurred()) SWIG_fail;
26960 }
26961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26962 return resultobj;
26963 fail:
26964 return NULL;
26965 }
26966
26967
26968 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26969 PyObject *resultobj = 0;
26970 wxPyApp *arg1 = (wxPyApp *) 0 ;
26971 void *argp1 = 0 ;
26972 int res1 = 0 ;
26973 PyObject *swig_obj[1] ;
26974
26975 if (!args) SWIG_fail;
26976 swig_obj[0] = args;
26977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26978 if (!SWIG_IsOK(res1)) {
26979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26980 }
26981 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26982 {
26983 PyThreadState* __tstate = wxPyBeginAllowThreads();
26984 delete arg1;
26985
26986 wxPyEndAllowThreads(__tstate);
26987 if (PyErr_Occurred()) SWIG_fail;
26988 }
26989 resultobj = SWIG_Py_Void();
26990 return resultobj;
26991 fail:
26992 return NULL;
26993 }
26994
26995
26996 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26997 PyObject *resultobj = 0;
26998 wxPyApp *arg1 = (wxPyApp *) 0 ;
26999 PyObject *arg2 = (PyObject *) 0 ;
27000 PyObject *arg3 = (PyObject *) 0 ;
27001 bool arg4 ;
27002 void *argp1 = 0 ;
27003 int res1 = 0 ;
27004 bool val4 ;
27005 int ecode4 = 0 ;
27006 PyObject * obj0 = 0 ;
27007 PyObject * obj1 = 0 ;
27008 PyObject * obj2 = 0 ;
27009 PyObject * obj3 = 0 ;
27010 char * kwnames[] = {
27011 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27012 };
27013
27014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27016 if (!SWIG_IsOK(res1)) {
27017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27018 }
27019 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27020 arg2 = obj1;
27021 arg3 = obj2;
27022 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27023 if (!SWIG_IsOK(ecode4)) {
27024 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27025 }
27026 arg4 = static_cast< bool >(val4);
27027 {
27028 PyThreadState* __tstate = wxPyBeginAllowThreads();
27029 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27030 wxPyEndAllowThreads(__tstate);
27031 if (PyErr_Occurred()) SWIG_fail;
27032 }
27033 resultobj = SWIG_Py_Void();
27034 return resultobj;
27035 fail:
27036 return NULL;
27037 }
27038
27039
27040 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27041 PyObject *resultobj = 0;
27042 wxPyApp *arg1 = (wxPyApp *) 0 ;
27043 wxString result;
27044 void *argp1 = 0 ;
27045 int res1 = 0 ;
27046 PyObject *swig_obj[1] ;
27047
27048 if (!args) SWIG_fail;
27049 swig_obj[0] = args;
27050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27051 if (!SWIG_IsOK(res1)) {
27052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27053 }
27054 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27055 {
27056 PyThreadState* __tstate = wxPyBeginAllowThreads();
27057 result = ((wxPyApp const *)arg1)->GetAppName();
27058 wxPyEndAllowThreads(__tstate);
27059 if (PyErr_Occurred()) SWIG_fail;
27060 }
27061 {
27062 #if wxUSE_UNICODE
27063 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27064 #else
27065 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27066 #endif
27067 }
27068 return resultobj;
27069 fail:
27070 return NULL;
27071 }
27072
27073
27074 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27075 PyObject *resultobj = 0;
27076 wxPyApp *arg1 = (wxPyApp *) 0 ;
27077 wxString *arg2 = 0 ;
27078 void *argp1 = 0 ;
27079 int res1 = 0 ;
27080 bool temp2 = false ;
27081 PyObject * obj0 = 0 ;
27082 PyObject * obj1 = 0 ;
27083 char * kwnames[] = {
27084 (char *) "self",(char *) "name", NULL
27085 };
27086
27087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27089 if (!SWIG_IsOK(res1)) {
27090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27091 }
27092 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27093 {
27094 arg2 = wxString_in_helper(obj1);
27095 if (arg2 == NULL) SWIG_fail;
27096 temp2 = true;
27097 }
27098 {
27099 PyThreadState* __tstate = wxPyBeginAllowThreads();
27100 (arg1)->SetAppName((wxString const &)*arg2);
27101 wxPyEndAllowThreads(__tstate);
27102 if (PyErr_Occurred()) SWIG_fail;
27103 }
27104 resultobj = SWIG_Py_Void();
27105 {
27106 if (temp2)
27107 delete arg2;
27108 }
27109 return resultobj;
27110 fail:
27111 {
27112 if (temp2)
27113 delete arg2;
27114 }
27115 return NULL;
27116 }
27117
27118
27119 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27120 PyObject *resultobj = 0;
27121 wxPyApp *arg1 = (wxPyApp *) 0 ;
27122 wxString result;
27123 void *argp1 = 0 ;
27124 int res1 = 0 ;
27125 PyObject *swig_obj[1] ;
27126
27127 if (!args) SWIG_fail;
27128 swig_obj[0] = args;
27129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27130 if (!SWIG_IsOK(res1)) {
27131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27132 }
27133 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27134 {
27135 PyThreadState* __tstate = wxPyBeginAllowThreads();
27136 result = ((wxPyApp const *)arg1)->GetClassName();
27137 wxPyEndAllowThreads(__tstate);
27138 if (PyErr_Occurred()) SWIG_fail;
27139 }
27140 {
27141 #if wxUSE_UNICODE
27142 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27143 #else
27144 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27145 #endif
27146 }
27147 return resultobj;
27148 fail:
27149 return NULL;
27150 }
27151
27152
27153 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27154 PyObject *resultobj = 0;
27155 wxPyApp *arg1 = (wxPyApp *) 0 ;
27156 wxString *arg2 = 0 ;
27157 void *argp1 = 0 ;
27158 int res1 = 0 ;
27159 bool temp2 = false ;
27160 PyObject * obj0 = 0 ;
27161 PyObject * obj1 = 0 ;
27162 char * kwnames[] = {
27163 (char *) "self",(char *) "name", NULL
27164 };
27165
27166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27168 if (!SWIG_IsOK(res1)) {
27169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27170 }
27171 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27172 {
27173 arg2 = wxString_in_helper(obj1);
27174 if (arg2 == NULL) SWIG_fail;
27175 temp2 = true;
27176 }
27177 {
27178 PyThreadState* __tstate = wxPyBeginAllowThreads();
27179 (arg1)->SetClassName((wxString const &)*arg2);
27180 wxPyEndAllowThreads(__tstate);
27181 if (PyErr_Occurred()) SWIG_fail;
27182 }
27183 resultobj = SWIG_Py_Void();
27184 {
27185 if (temp2)
27186 delete arg2;
27187 }
27188 return resultobj;
27189 fail:
27190 {
27191 if (temp2)
27192 delete arg2;
27193 }
27194 return NULL;
27195 }
27196
27197
27198 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27199 PyObject *resultobj = 0;
27200 wxPyApp *arg1 = (wxPyApp *) 0 ;
27201 wxString *result = 0 ;
27202 void *argp1 = 0 ;
27203 int res1 = 0 ;
27204 PyObject *swig_obj[1] ;
27205
27206 if (!args) SWIG_fail;
27207 swig_obj[0] = args;
27208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27209 if (!SWIG_IsOK(res1)) {
27210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27211 }
27212 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27213 {
27214 PyThreadState* __tstate = wxPyBeginAllowThreads();
27215 {
27216 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27217 result = (wxString *) &_result_ref;
27218 }
27219 wxPyEndAllowThreads(__tstate);
27220 if (PyErr_Occurred()) SWIG_fail;
27221 }
27222 {
27223 #if wxUSE_UNICODE
27224 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27225 #else
27226 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27227 #endif
27228 }
27229 return resultobj;
27230 fail:
27231 return NULL;
27232 }
27233
27234
27235 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27236 PyObject *resultobj = 0;
27237 wxPyApp *arg1 = (wxPyApp *) 0 ;
27238 wxString *arg2 = 0 ;
27239 void *argp1 = 0 ;
27240 int res1 = 0 ;
27241 bool temp2 = false ;
27242 PyObject * obj0 = 0 ;
27243 PyObject * obj1 = 0 ;
27244 char * kwnames[] = {
27245 (char *) "self",(char *) "name", NULL
27246 };
27247
27248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27250 if (!SWIG_IsOK(res1)) {
27251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27252 }
27253 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27254 {
27255 arg2 = wxString_in_helper(obj1);
27256 if (arg2 == NULL) SWIG_fail;
27257 temp2 = true;
27258 }
27259 {
27260 PyThreadState* __tstate = wxPyBeginAllowThreads();
27261 (arg1)->SetVendorName((wxString const &)*arg2);
27262 wxPyEndAllowThreads(__tstate);
27263 if (PyErr_Occurred()) SWIG_fail;
27264 }
27265 resultobj = SWIG_Py_Void();
27266 {
27267 if (temp2)
27268 delete arg2;
27269 }
27270 return resultobj;
27271 fail:
27272 {
27273 if (temp2)
27274 delete arg2;
27275 }
27276 return NULL;
27277 }
27278
27279
27280 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27281 PyObject *resultobj = 0;
27282 wxPyApp *arg1 = (wxPyApp *) 0 ;
27283 wxAppTraits *result = 0 ;
27284 void *argp1 = 0 ;
27285 int res1 = 0 ;
27286 PyObject *swig_obj[1] ;
27287
27288 if (!args) SWIG_fail;
27289 swig_obj[0] = args;
27290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27291 if (!SWIG_IsOK(res1)) {
27292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27293 }
27294 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27295 {
27296 PyThreadState* __tstate = wxPyBeginAllowThreads();
27297 result = (wxAppTraits *)(arg1)->GetTraits();
27298 wxPyEndAllowThreads(__tstate);
27299 if (PyErr_Occurred()) SWIG_fail;
27300 }
27301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27302 return resultobj;
27303 fail:
27304 return NULL;
27305 }
27306
27307
27308 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27309 PyObject *resultobj = 0;
27310 wxPyApp *arg1 = (wxPyApp *) 0 ;
27311 void *argp1 = 0 ;
27312 int res1 = 0 ;
27313 PyObject *swig_obj[1] ;
27314
27315 if (!args) SWIG_fail;
27316 swig_obj[0] = args;
27317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27318 if (!SWIG_IsOK(res1)) {
27319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27320 }
27321 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27322 {
27323 PyThreadState* __tstate = wxPyBeginAllowThreads();
27324 (arg1)->ProcessPendingEvents();
27325 wxPyEndAllowThreads(__tstate);
27326 if (PyErr_Occurred()) SWIG_fail;
27327 }
27328 resultobj = SWIG_Py_Void();
27329 return resultobj;
27330 fail:
27331 return NULL;
27332 }
27333
27334
27335 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27336 PyObject *resultobj = 0;
27337 wxPyApp *arg1 = (wxPyApp *) 0 ;
27338 bool arg2 = (bool) false ;
27339 bool result;
27340 void *argp1 = 0 ;
27341 int res1 = 0 ;
27342 bool val2 ;
27343 int ecode2 = 0 ;
27344 PyObject * obj0 = 0 ;
27345 PyObject * obj1 = 0 ;
27346 char * kwnames[] = {
27347 (char *) "self",(char *) "onlyIfNeeded", NULL
27348 };
27349
27350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27352 if (!SWIG_IsOK(res1)) {
27353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27354 }
27355 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27356 if (obj1) {
27357 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27358 if (!SWIG_IsOK(ecode2)) {
27359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27360 }
27361 arg2 = static_cast< bool >(val2);
27362 }
27363 {
27364 PyThreadState* __tstate = wxPyBeginAllowThreads();
27365 result = (bool)(arg1)->Yield(arg2);
27366 wxPyEndAllowThreads(__tstate);
27367 if (PyErr_Occurred()) SWIG_fail;
27368 }
27369 {
27370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27371 }
27372 return resultobj;
27373 fail:
27374 return NULL;
27375 }
27376
27377
27378 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27379 PyObject *resultobj = 0;
27380 wxPyApp *arg1 = (wxPyApp *) 0 ;
27381 void *argp1 = 0 ;
27382 int res1 = 0 ;
27383 PyObject *swig_obj[1] ;
27384
27385 if (!args) SWIG_fail;
27386 swig_obj[0] = args;
27387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27388 if (!SWIG_IsOK(res1)) {
27389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27390 }
27391 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27392 {
27393 PyThreadState* __tstate = wxPyBeginAllowThreads();
27394 (arg1)->WakeUpIdle();
27395 wxPyEndAllowThreads(__tstate);
27396 if (PyErr_Occurred()) SWIG_fail;
27397 }
27398 resultobj = SWIG_Py_Void();
27399 return resultobj;
27400 fail:
27401 return NULL;
27402 }
27403
27404
27405 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27406 PyObject *resultobj = 0;
27407 bool result;
27408
27409 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27410 {
27411 PyThreadState* __tstate = wxPyBeginAllowThreads();
27412 result = (bool)wxPyApp::IsMainLoopRunning();
27413 wxPyEndAllowThreads(__tstate);
27414 if (PyErr_Occurred()) SWIG_fail;
27415 }
27416 {
27417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27418 }
27419 return resultobj;
27420 fail:
27421 return NULL;
27422 }
27423
27424
27425 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27426 PyObject *resultobj = 0;
27427 wxPyApp *arg1 = (wxPyApp *) 0 ;
27428 int result;
27429 void *argp1 = 0 ;
27430 int res1 = 0 ;
27431 PyObject *swig_obj[1] ;
27432
27433 if (!args) SWIG_fail;
27434 swig_obj[0] = args;
27435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27436 if (!SWIG_IsOK(res1)) {
27437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27438 }
27439 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27440 {
27441 PyThreadState* __tstate = wxPyBeginAllowThreads();
27442 result = (int)(arg1)->MainLoop();
27443 wxPyEndAllowThreads(__tstate);
27444 if (PyErr_Occurred()) SWIG_fail;
27445 }
27446 resultobj = SWIG_From_int(static_cast< int >(result));
27447 return resultobj;
27448 fail:
27449 return NULL;
27450 }
27451
27452
27453 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27454 PyObject *resultobj = 0;
27455 wxPyApp *arg1 = (wxPyApp *) 0 ;
27456 void *argp1 = 0 ;
27457 int res1 = 0 ;
27458 PyObject *swig_obj[1] ;
27459
27460 if (!args) SWIG_fail;
27461 swig_obj[0] = args;
27462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27463 if (!SWIG_IsOK(res1)) {
27464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27465 }
27466 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27467 {
27468 PyThreadState* __tstate = wxPyBeginAllowThreads();
27469 (arg1)->Exit();
27470 wxPyEndAllowThreads(__tstate);
27471 if (PyErr_Occurred()) SWIG_fail;
27472 }
27473 resultobj = SWIG_Py_Void();
27474 return resultobj;
27475 fail:
27476 return NULL;
27477 }
27478
27479
27480 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27481 PyObject *resultobj = 0;
27482 wxPyApp *arg1 = (wxPyApp *) 0 ;
27483 void *argp1 = 0 ;
27484 int res1 = 0 ;
27485 PyObject *swig_obj[1] ;
27486
27487 if (!args) SWIG_fail;
27488 swig_obj[0] = args;
27489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27490 if (!SWIG_IsOK(res1)) {
27491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27492 }
27493 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27494 {
27495 PyThreadState* __tstate = wxPyBeginAllowThreads();
27496 (arg1)->ExitMainLoop();
27497 wxPyEndAllowThreads(__tstate);
27498 if (PyErr_Occurred()) SWIG_fail;
27499 }
27500 resultobj = SWIG_Py_Void();
27501 return resultobj;
27502 fail:
27503 return NULL;
27504 }
27505
27506
27507 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27508 PyObject *resultobj = 0;
27509 wxPyApp *arg1 = (wxPyApp *) 0 ;
27510 bool result;
27511 void *argp1 = 0 ;
27512 int res1 = 0 ;
27513 PyObject *swig_obj[1] ;
27514
27515 if (!args) SWIG_fail;
27516 swig_obj[0] = args;
27517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27518 if (!SWIG_IsOK(res1)) {
27519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27520 }
27521 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27522 {
27523 PyThreadState* __tstate = wxPyBeginAllowThreads();
27524 result = (bool)(arg1)->Pending();
27525 wxPyEndAllowThreads(__tstate);
27526 if (PyErr_Occurred()) SWIG_fail;
27527 }
27528 {
27529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27530 }
27531 return resultobj;
27532 fail:
27533 return NULL;
27534 }
27535
27536
27537 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27538 PyObject *resultobj = 0;
27539 wxPyApp *arg1 = (wxPyApp *) 0 ;
27540 bool result;
27541 void *argp1 = 0 ;
27542 int res1 = 0 ;
27543 PyObject *swig_obj[1] ;
27544
27545 if (!args) SWIG_fail;
27546 swig_obj[0] = args;
27547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27548 if (!SWIG_IsOK(res1)) {
27549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27550 }
27551 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27552 {
27553 PyThreadState* __tstate = wxPyBeginAllowThreads();
27554 result = (bool)(arg1)->Dispatch();
27555 wxPyEndAllowThreads(__tstate);
27556 if (PyErr_Occurred()) SWIG_fail;
27557 }
27558 {
27559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27560 }
27561 return resultobj;
27562 fail:
27563 return NULL;
27564 }
27565
27566
27567 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27568 PyObject *resultobj = 0;
27569 wxPyApp *arg1 = (wxPyApp *) 0 ;
27570 bool result;
27571 void *argp1 = 0 ;
27572 int res1 = 0 ;
27573 PyObject *swig_obj[1] ;
27574
27575 if (!args) SWIG_fail;
27576 swig_obj[0] = args;
27577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27578 if (!SWIG_IsOK(res1)) {
27579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27580 }
27581 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27582 {
27583 PyThreadState* __tstate = wxPyBeginAllowThreads();
27584 result = (bool)(arg1)->ProcessIdle();
27585 wxPyEndAllowThreads(__tstate);
27586 if (PyErr_Occurred()) SWIG_fail;
27587 }
27588 {
27589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27590 }
27591 return resultobj;
27592 fail:
27593 return NULL;
27594 }
27595
27596
27597 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27598 PyObject *resultobj = 0;
27599 wxPyApp *arg1 = (wxPyApp *) 0 ;
27600 wxWindow *arg2 = (wxWindow *) 0 ;
27601 wxIdleEvent *arg3 = 0 ;
27602 bool result;
27603 void *argp1 = 0 ;
27604 int res1 = 0 ;
27605 void *argp2 = 0 ;
27606 int res2 = 0 ;
27607 void *argp3 = 0 ;
27608 int res3 = 0 ;
27609 PyObject * obj0 = 0 ;
27610 PyObject * obj1 = 0 ;
27611 PyObject * obj2 = 0 ;
27612 char * kwnames[] = {
27613 (char *) "self",(char *) "win",(char *) "event", NULL
27614 };
27615
27616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27618 if (!SWIG_IsOK(res1)) {
27619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27620 }
27621 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27622 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27623 if (!SWIG_IsOK(res2)) {
27624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27625 }
27626 arg2 = reinterpret_cast< wxWindow * >(argp2);
27627 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27628 if (!SWIG_IsOK(res3)) {
27629 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27630 }
27631 if (!argp3) {
27632 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27633 }
27634 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27635 {
27636 PyThreadState* __tstate = wxPyBeginAllowThreads();
27637 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27638 wxPyEndAllowThreads(__tstate);
27639 if (PyErr_Occurred()) SWIG_fail;
27640 }
27641 {
27642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27643 }
27644 return resultobj;
27645 fail:
27646 return NULL;
27647 }
27648
27649
27650 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27651 PyObject *resultobj = 0;
27652 wxPyApp *arg1 = (wxPyApp *) 0 ;
27653 bool result;
27654 void *argp1 = 0 ;
27655 int res1 = 0 ;
27656 PyObject *swig_obj[1] ;
27657
27658 if (!args) SWIG_fail;
27659 swig_obj[0] = args;
27660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27661 if (!SWIG_IsOK(res1)) {
27662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27663 }
27664 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27665 {
27666 PyThreadState* __tstate = wxPyBeginAllowThreads();
27667 result = (bool)((wxPyApp const *)arg1)->IsActive();
27668 wxPyEndAllowThreads(__tstate);
27669 if (PyErr_Occurred()) SWIG_fail;
27670 }
27671 {
27672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27673 }
27674 return resultobj;
27675 fail:
27676 return NULL;
27677 }
27678
27679
27680 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27681 PyObject *resultobj = 0;
27682 wxPyApp *arg1 = (wxPyApp *) 0 ;
27683 wxWindow *arg2 = (wxWindow *) 0 ;
27684 void *argp1 = 0 ;
27685 int res1 = 0 ;
27686 void *argp2 = 0 ;
27687 int res2 = 0 ;
27688 PyObject * obj0 = 0 ;
27689 PyObject * obj1 = 0 ;
27690 char * kwnames[] = {
27691 (char *) "self",(char *) "win", NULL
27692 };
27693
27694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27696 if (!SWIG_IsOK(res1)) {
27697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27698 }
27699 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27700 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27701 if (!SWIG_IsOK(res2)) {
27702 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27703 }
27704 arg2 = reinterpret_cast< wxWindow * >(argp2);
27705 {
27706 PyThreadState* __tstate = wxPyBeginAllowThreads();
27707 (arg1)->SetTopWindow(arg2);
27708 wxPyEndAllowThreads(__tstate);
27709 if (PyErr_Occurred()) SWIG_fail;
27710 }
27711 resultobj = SWIG_Py_Void();
27712 return resultobj;
27713 fail:
27714 return NULL;
27715 }
27716
27717
27718 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27719 PyObject *resultobj = 0;
27720 wxPyApp *arg1 = (wxPyApp *) 0 ;
27721 wxWindow *result = 0 ;
27722 void *argp1 = 0 ;
27723 int res1 = 0 ;
27724 PyObject *swig_obj[1] ;
27725
27726 if (!args) SWIG_fail;
27727 swig_obj[0] = args;
27728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27729 if (!SWIG_IsOK(res1)) {
27730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27731 }
27732 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27733 {
27734 PyThreadState* __tstate = wxPyBeginAllowThreads();
27735 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27736 wxPyEndAllowThreads(__tstate);
27737 if (PyErr_Occurred()) SWIG_fail;
27738 }
27739 {
27740 resultobj = wxPyMake_wxObject(result, (bool)0);
27741 }
27742 return resultobj;
27743 fail:
27744 return NULL;
27745 }
27746
27747
27748 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27749 PyObject *resultobj = 0;
27750 wxPyApp *arg1 = (wxPyApp *) 0 ;
27751 bool arg2 ;
27752 void *argp1 = 0 ;
27753 int res1 = 0 ;
27754 bool val2 ;
27755 int ecode2 = 0 ;
27756 PyObject * obj0 = 0 ;
27757 PyObject * obj1 = 0 ;
27758 char * kwnames[] = {
27759 (char *) "self",(char *) "flag", NULL
27760 };
27761
27762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27764 if (!SWIG_IsOK(res1)) {
27765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27766 }
27767 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27768 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27769 if (!SWIG_IsOK(ecode2)) {
27770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27771 }
27772 arg2 = static_cast< bool >(val2);
27773 {
27774 PyThreadState* __tstate = wxPyBeginAllowThreads();
27775 (arg1)->SetExitOnFrameDelete(arg2);
27776 wxPyEndAllowThreads(__tstate);
27777 if (PyErr_Occurred()) SWIG_fail;
27778 }
27779 resultobj = SWIG_Py_Void();
27780 return resultobj;
27781 fail:
27782 return NULL;
27783 }
27784
27785
27786 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27787 PyObject *resultobj = 0;
27788 wxPyApp *arg1 = (wxPyApp *) 0 ;
27789 bool result;
27790 void *argp1 = 0 ;
27791 int res1 = 0 ;
27792 PyObject *swig_obj[1] ;
27793
27794 if (!args) SWIG_fail;
27795 swig_obj[0] = args;
27796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27797 if (!SWIG_IsOK(res1)) {
27798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27799 }
27800 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27801 {
27802 PyThreadState* __tstate = wxPyBeginAllowThreads();
27803 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27804 wxPyEndAllowThreads(__tstate);
27805 if (PyErr_Occurred()) SWIG_fail;
27806 }
27807 {
27808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27809 }
27810 return resultobj;
27811 fail:
27812 return NULL;
27813 }
27814
27815
27816 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27817 PyObject *resultobj = 0;
27818 wxPyApp *arg1 = (wxPyApp *) 0 ;
27819 bool arg2 ;
27820 void *argp1 = 0 ;
27821 int res1 = 0 ;
27822 bool val2 ;
27823 int ecode2 = 0 ;
27824 PyObject * obj0 = 0 ;
27825 PyObject * obj1 = 0 ;
27826 char * kwnames[] = {
27827 (char *) "self",(char *) "flag", NULL
27828 };
27829
27830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27832 if (!SWIG_IsOK(res1)) {
27833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27834 }
27835 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27836 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27837 if (!SWIG_IsOK(ecode2)) {
27838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27839 }
27840 arg2 = static_cast< bool >(val2);
27841 {
27842 PyThreadState* __tstate = wxPyBeginAllowThreads();
27843 (arg1)->SetUseBestVisual(arg2);
27844 wxPyEndAllowThreads(__tstate);
27845 if (PyErr_Occurred()) SWIG_fail;
27846 }
27847 resultobj = SWIG_Py_Void();
27848 return resultobj;
27849 fail:
27850 return NULL;
27851 }
27852
27853
27854 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27855 PyObject *resultobj = 0;
27856 wxPyApp *arg1 = (wxPyApp *) 0 ;
27857 bool result;
27858 void *argp1 = 0 ;
27859 int res1 = 0 ;
27860 PyObject *swig_obj[1] ;
27861
27862 if (!args) SWIG_fail;
27863 swig_obj[0] = args;
27864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27865 if (!SWIG_IsOK(res1)) {
27866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27867 }
27868 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27869 {
27870 PyThreadState* __tstate = wxPyBeginAllowThreads();
27871 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27872 wxPyEndAllowThreads(__tstate);
27873 if (PyErr_Occurred()) SWIG_fail;
27874 }
27875 {
27876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27877 }
27878 return resultobj;
27879 fail:
27880 return NULL;
27881 }
27882
27883
27884 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27885 PyObject *resultobj = 0;
27886 wxPyApp *arg1 = (wxPyApp *) 0 ;
27887 int arg2 ;
27888 void *argp1 = 0 ;
27889 int res1 = 0 ;
27890 int val2 ;
27891 int ecode2 = 0 ;
27892 PyObject * obj0 = 0 ;
27893 PyObject * obj1 = 0 ;
27894 char * kwnames[] = {
27895 (char *) "self",(char *) "mode", NULL
27896 };
27897
27898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27900 if (!SWIG_IsOK(res1)) {
27901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27902 }
27903 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27904 ecode2 = SWIG_AsVal_int(obj1, &val2);
27905 if (!SWIG_IsOK(ecode2)) {
27906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27907 }
27908 arg2 = static_cast< int >(val2);
27909 {
27910 PyThreadState* __tstate = wxPyBeginAllowThreads();
27911 (arg1)->SetPrintMode(arg2);
27912 wxPyEndAllowThreads(__tstate);
27913 if (PyErr_Occurred()) SWIG_fail;
27914 }
27915 resultobj = SWIG_Py_Void();
27916 return resultobj;
27917 fail:
27918 return NULL;
27919 }
27920
27921
27922 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27923 PyObject *resultobj = 0;
27924 wxPyApp *arg1 = (wxPyApp *) 0 ;
27925 int result;
27926 void *argp1 = 0 ;
27927 int res1 = 0 ;
27928 PyObject *swig_obj[1] ;
27929
27930 if (!args) SWIG_fail;
27931 swig_obj[0] = args;
27932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27933 if (!SWIG_IsOK(res1)) {
27934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27935 }
27936 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27937 {
27938 PyThreadState* __tstate = wxPyBeginAllowThreads();
27939 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27940 wxPyEndAllowThreads(__tstate);
27941 if (PyErr_Occurred()) SWIG_fail;
27942 }
27943 resultobj = SWIG_From_int(static_cast< int >(result));
27944 return resultobj;
27945 fail:
27946 return NULL;
27947 }
27948
27949
27950 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27951 PyObject *resultobj = 0;
27952 wxPyApp *arg1 = (wxPyApp *) 0 ;
27953 int arg2 ;
27954 void *argp1 = 0 ;
27955 int res1 = 0 ;
27956 int val2 ;
27957 int ecode2 = 0 ;
27958 PyObject * obj0 = 0 ;
27959 PyObject * obj1 = 0 ;
27960 char * kwnames[] = {
27961 (char *) "self",(char *) "mode", NULL
27962 };
27963
27964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27966 if (!SWIG_IsOK(res1)) {
27967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27968 }
27969 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27970 ecode2 = SWIG_AsVal_int(obj1, &val2);
27971 if (!SWIG_IsOK(ecode2)) {
27972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27973 }
27974 arg2 = static_cast< int >(val2);
27975 {
27976 PyThreadState* __tstate = wxPyBeginAllowThreads();
27977 (arg1)->SetAssertMode(arg2);
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_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27989 PyObject *resultobj = 0;
27990 wxPyApp *arg1 = (wxPyApp *) 0 ;
27991 int result;
27992 void *argp1 = 0 ;
27993 int res1 = 0 ;
27994 PyObject *swig_obj[1] ;
27995
27996 if (!args) SWIG_fail;
27997 swig_obj[0] = args;
27998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27999 if (!SWIG_IsOK(res1)) {
28000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28001 }
28002 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28003 {
28004 PyThreadState* __tstate = wxPyBeginAllowThreads();
28005 result = (int)(arg1)->GetAssertMode();
28006 wxPyEndAllowThreads(__tstate);
28007 if (PyErr_Occurred()) SWIG_fail;
28008 }
28009 resultobj = SWIG_From_int(static_cast< int >(result));
28010 return resultobj;
28011 fail:
28012 return NULL;
28013 }
28014
28015
28016 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28017 PyObject *resultobj = 0;
28018 bool result;
28019
28020 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28021 {
28022 PyThreadState* __tstate = wxPyBeginAllowThreads();
28023 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28024 wxPyEndAllowThreads(__tstate);
28025 if (PyErr_Occurred()) SWIG_fail;
28026 }
28027 {
28028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28029 }
28030 return resultobj;
28031 fail:
28032 return NULL;
28033 }
28034
28035
28036 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28037 PyObject *resultobj = 0;
28038 long result;
28039
28040 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28041 {
28042 PyThreadState* __tstate = wxPyBeginAllowThreads();
28043 result = (long)wxPyApp::GetMacAboutMenuItemId();
28044 wxPyEndAllowThreads(__tstate);
28045 if (PyErr_Occurred()) SWIG_fail;
28046 }
28047 resultobj = SWIG_From_long(static_cast< long >(result));
28048 return resultobj;
28049 fail:
28050 return NULL;
28051 }
28052
28053
28054 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28055 PyObject *resultobj = 0;
28056 long result;
28057
28058 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28059 {
28060 PyThreadState* __tstate = wxPyBeginAllowThreads();
28061 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28062 wxPyEndAllowThreads(__tstate);
28063 if (PyErr_Occurred()) SWIG_fail;
28064 }
28065 resultobj = SWIG_From_long(static_cast< long >(result));
28066 return resultobj;
28067 fail:
28068 return NULL;
28069 }
28070
28071
28072 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28073 PyObject *resultobj = 0;
28074 long result;
28075
28076 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28077 {
28078 PyThreadState* __tstate = wxPyBeginAllowThreads();
28079 result = (long)wxPyApp::GetMacExitMenuItemId();
28080 wxPyEndAllowThreads(__tstate);
28081 if (PyErr_Occurred()) SWIG_fail;
28082 }
28083 resultobj = SWIG_From_long(static_cast< long >(result));
28084 return resultobj;
28085 fail:
28086 return NULL;
28087 }
28088
28089
28090 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28091 PyObject *resultobj = 0;
28092 wxString result;
28093
28094 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28095 {
28096 PyThreadState* __tstate = wxPyBeginAllowThreads();
28097 result = wxPyApp::GetMacHelpMenuTitleName();
28098 wxPyEndAllowThreads(__tstate);
28099 if (PyErr_Occurred()) SWIG_fail;
28100 }
28101 {
28102 #if wxUSE_UNICODE
28103 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28104 #else
28105 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28106 #endif
28107 }
28108 return resultobj;
28109 fail:
28110 return NULL;
28111 }
28112
28113
28114 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28115 PyObject *resultobj = 0;
28116 bool arg1 ;
28117 bool val1 ;
28118 int ecode1 = 0 ;
28119 PyObject * obj0 = 0 ;
28120 char * kwnames[] = {
28121 (char *) "val", NULL
28122 };
28123
28124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28125 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28126 if (!SWIG_IsOK(ecode1)) {
28127 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28128 }
28129 arg1 = static_cast< bool >(val1);
28130 {
28131 PyThreadState* __tstate = wxPyBeginAllowThreads();
28132 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28133 wxPyEndAllowThreads(__tstate);
28134 if (PyErr_Occurred()) SWIG_fail;
28135 }
28136 resultobj = SWIG_Py_Void();
28137 return resultobj;
28138 fail:
28139 return NULL;
28140 }
28141
28142
28143 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28144 PyObject *resultobj = 0;
28145 long arg1 ;
28146 long val1 ;
28147 int ecode1 = 0 ;
28148 PyObject * obj0 = 0 ;
28149 char * kwnames[] = {
28150 (char *) "val", NULL
28151 };
28152
28153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28154 ecode1 = SWIG_AsVal_long(obj0, &val1);
28155 if (!SWIG_IsOK(ecode1)) {
28156 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28157 }
28158 arg1 = static_cast< long >(val1);
28159 {
28160 PyThreadState* __tstate = wxPyBeginAllowThreads();
28161 wxPyApp::SetMacAboutMenuItemId(arg1);
28162 wxPyEndAllowThreads(__tstate);
28163 if (PyErr_Occurred()) SWIG_fail;
28164 }
28165 resultobj = SWIG_Py_Void();
28166 return resultobj;
28167 fail:
28168 return NULL;
28169 }
28170
28171
28172 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28173 PyObject *resultobj = 0;
28174 long arg1 ;
28175 long val1 ;
28176 int ecode1 = 0 ;
28177 PyObject * obj0 = 0 ;
28178 char * kwnames[] = {
28179 (char *) "val", NULL
28180 };
28181
28182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28183 ecode1 = SWIG_AsVal_long(obj0, &val1);
28184 if (!SWIG_IsOK(ecode1)) {
28185 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28186 }
28187 arg1 = static_cast< long >(val1);
28188 {
28189 PyThreadState* __tstate = wxPyBeginAllowThreads();
28190 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28191 wxPyEndAllowThreads(__tstate);
28192 if (PyErr_Occurred()) SWIG_fail;
28193 }
28194 resultobj = SWIG_Py_Void();
28195 return resultobj;
28196 fail:
28197 return NULL;
28198 }
28199
28200
28201 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28202 PyObject *resultobj = 0;
28203 long arg1 ;
28204 long val1 ;
28205 int ecode1 = 0 ;
28206 PyObject * obj0 = 0 ;
28207 char * kwnames[] = {
28208 (char *) "val", NULL
28209 };
28210
28211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28212 ecode1 = SWIG_AsVal_long(obj0, &val1);
28213 if (!SWIG_IsOK(ecode1)) {
28214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28215 }
28216 arg1 = static_cast< long >(val1);
28217 {
28218 PyThreadState* __tstate = wxPyBeginAllowThreads();
28219 wxPyApp::SetMacExitMenuItemId(arg1);
28220 wxPyEndAllowThreads(__tstate);
28221 if (PyErr_Occurred()) SWIG_fail;
28222 }
28223 resultobj = SWIG_Py_Void();
28224 return resultobj;
28225 fail:
28226 return NULL;
28227 }
28228
28229
28230 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28231 PyObject *resultobj = 0;
28232 wxString *arg1 = 0 ;
28233 bool temp1 = false ;
28234 PyObject * obj0 = 0 ;
28235 char * kwnames[] = {
28236 (char *) "val", NULL
28237 };
28238
28239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28240 {
28241 arg1 = wxString_in_helper(obj0);
28242 if (arg1 == NULL) SWIG_fail;
28243 temp1 = true;
28244 }
28245 {
28246 PyThreadState* __tstate = wxPyBeginAllowThreads();
28247 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28248 wxPyEndAllowThreads(__tstate);
28249 if (PyErr_Occurred()) SWIG_fail;
28250 }
28251 resultobj = SWIG_Py_Void();
28252 {
28253 if (temp1)
28254 delete arg1;
28255 }
28256 return resultobj;
28257 fail:
28258 {
28259 if (temp1)
28260 delete arg1;
28261 }
28262 return NULL;
28263 }
28264
28265
28266 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28267 PyObject *resultobj = 0;
28268 wxPyApp *arg1 = (wxPyApp *) 0 ;
28269 void *argp1 = 0 ;
28270 int res1 = 0 ;
28271 PyObject *swig_obj[1] ;
28272
28273 if (!args) SWIG_fail;
28274 swig_obj[0] = args;
28275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28276 if (!SWIG_IsOK(res1)) {
28277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28278 }
28279 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28280 {
28281 PyThreadState* __tstate = wxPyBeginAllowThreads();
28282 (arg1)->_BootstrapApp();
28283 wxPyEndAllowThreads(__tstate);
28284 if (PyErr_Occurred()) SWIG_fail;
28285 }
28286 resultobj = SWIG_Py_Void();
28287 return resultobj;
28288 fail:
28289 return NULL;
28290 }
28291
28292
28293 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28294 PyObject *resultobj = 0;
28295 int result;
28296
28297 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28298 {
28299 PyThreadState* __tstate = wxPyBeginAllowThreads();
28300 result = (int)wxPyApp_GetComCtl32Version();
28301 wxPyEndAllowThreads(__tstate);
28302 if (PyErr_Occurred()) SWIG_fail;
28303 }
28304 resultobj = SWIG_From_int(static_cast< int >(result));
28305 return resultobj;
28306 fail:
28307 return NULL;
28308 }
28309
28310
28311 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28312 PyObject *obj;
28313 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28314 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28315 return SWIG_Py_Void();
28316 }
28317
28318 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28319 return SWIG_Python_InitShadowInstance(args);
28320 }
28321
28322 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28323 PyObject *resultobj = 0;
28324
28325 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28326 {
28327 PyThreadState* __tstate = wxPyBeginAllowThreads();
28328 wxExit();
28329 wxPyEndAllowThreads(__tstate);
28330 if (PyErr_Occurred()) SWIG_fail;
28331 }
28332 resultobj = SWIG_Py_Void();
28333 return resultobj;
28334 fail:
28335 return NULL;
28336 }
28337
28338
28339 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28340 PyObject *resultobj = 0;
28341 bool result;
28342
28343 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28344 {
28345 PyThreadState* __tstate = wxPyBeginAllowThreads();
28346 result = (bool)wxYield();
28347 wxPyEndAllowThreads(__tstate);
28348 if (PyErr_Occurred()) SWIG_fail;
28349 }
28350 {
28351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28352 }
28353 return resultobj;
28354 fail:
28355 return NULL;
28356 }
28357
28358
28359 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28360 PyObject *resultobj = 0;
28361 bool result;
28362
28363 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28364 {
28365 PyThreadState* __tstate = wxPyBeginAllowThreads();
28366 result = (bool)wxYieldIfNeeded();
28367 wxPyEndAllowThreads(__tstate);
28368 if (PyErr_Occurred()) SWIG_fail;
28369 }
28370 {
28371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28372 }
28373 return resultobj;
28374 fail:
28375 return NULL;
28376 }
28377
28378
28379 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28380 PyObject *resultobj = 0;
28381 wxWindow *arg1 = (wxWindow *) NULL ;
28382 bool arg2 = (bool) false ;
28383 bool result;
28384 void *argp1 = 0 ;
28385 int res1 = 0 ;
28386 bool val2 ;
28387 int ecode2 = 0 ;
28388 PyObject * obj0 = 0 ;
28389 PyObject * obj1 = 0 ;
28390 char * kwnames[] = {
28391 (char *) "win",(char *) "onlyIfNeeded", NULL
28392 };
28393
28394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28395 if (obj0) {
28396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28397 if (!SWIG_IsOK(res1)) {
28398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28399 }
28400 arg1 = reinterpret_cast< wxWindow * >(argp1);
28401 }
28402 if (obj1) {
28403 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28404 if (!SWIG_IsOK(ecode2)) {
28405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28406 }
28407 arg2 = static_cast< bool >(val2);
28408 }
28409 {
28410 PyThreadState* __tstate = wxPyBeginAllowThreads();
28411 result = (bool)wxSafeYield(arg1,arg2);
28412 wxPyEndAllowThreads(__tstate);
28413 if (PyErr_Occurred()) SWIG_fail;
28414 }
28415 {
28416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28417 }
28418 return resultobj;
28419 fail:
28420 return NULL;
28421 }
28422
28423
28424 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28425 PyObject *resultobj = 0;
28426
28427 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28428 {
28429 PyThreadState* __tstate = wxPyBeginAllowThreads();
28430 wxWakeUpIdle();
28431 wxPyEndAllowThreads(__tstate);
28432 if (PyErr_Occurred()) SWIG_fail;
28433 }
28434 resultobj = SWIG_Py_Void();
28435 return resultobj;
28436 fail:
28437 return NULL;
28438 }
28439
28440
28441 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28442 PyObject *resultobj = 0;
28443 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28444 wxEvent *arg2 = 0 ;
28445 void *argp1 = 0 ;
28446 int res1 = 0 ;
28447 void *argp2 = 0 ;
28448 int res2 = 0 ;
28449 PyObject * obj0 = 0 ;
28450 PyObject * obj1 = 0 ;
28451 char * kwnames[] = {
28452 (char *) "dest",(char *) "event", NULL
28453 };
28454
28455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28457 if (!SWIG_IsOK(res1)) {
28458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28459 }
28460 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28461 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28462 if (!SWIG_IsOK(res2)) {
28463 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28464 }
28465 if (!argp2) {
28466 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28467 }
28468 arg2 = reinterpret_cast< wxEvent * >(argp2);
28469 {
28470 PyThreadState* __tstate = wxPyBeginAllowThreads();
28471 wxPostEvent(arg1,*arg2);
28472 wxPyEndAllowThreads(__tstate);
28473 if (PyErr_Occurred()) SWIG_fail;
28474 }
28475 resultobj = SWIG_Py_Void();
28476 return resultobj;
28477 fail:
28478 return NULL;
28479 }
28480
28481
28482 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28483 PyObject *resultobj = 0;
28484
28485 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28486 {
28487 PyThreadState* __tstate = wxPyBeginAllowThreads();
28488 wxApp_CleanUp();
28489 wxPyEndAllowThreads(__tstate);
28490 if (PyErr_Occurred()) SWIG_fail;
28491 }
28492 resultobj = SWIG_Py_Void();
28493 return resultobj;
28494 fail:
28495 return NULL;
28496 }
28497
28498
28499 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28500 PyObject *resultobj = 0;
28501 wxPyApp *result = 0 ;
28502
28503 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28504 {
28505 PyThreadState* __tstate = wxPyBeginAllowThreads();
28506 result = (wxPyApp *)wxPyGetApp();
28507 wxPyEndAllowThreads(__tstate);
28508 if (PyErr_Occurred()) SWIG_fail;
28509 }
28510 {
28511 resultobj = wxPyMake_wxObject(result, 0);
28512 }
28513 return resultobj;
28514 fail:
28515 return NULL;
28516 }
28517
28518
28519 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28520 PyObject *resultobj = 0;
28521 char *arg1 = (char *) 0 ;
28522 int res1 ;
28523 char *buf1 = 0 ;
28524 int alloc1 = 0 ;
28525 PyObject * obj0 = 0 ;
28526 char * kwnames[] = {
28527 (char *) "encoding", NULL
28528 };
28529
28530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28531 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28532 if (!SWIG_IsOK(res1)) {
28533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28534 }
28535 arg1 = buf1;
28536 {
28537 PyThreadState* __tstate = wxPyBeginAllowThreads();
28538 wxSetDefaultPyEncoding((char const *)arg1);
28539 wxPyEndAllowThreads(__tstate);
28540 if (PyErr_Occurred()) SWIG_fail;
28541 }
28542 resultobj = SWIG_Py_Void();
28543 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28544 return resultobj;
28545 fail:
28546 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28547 return NULL;
28548 }
28549
28550
28551 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28552 PyObject *resultobj = 0;
28553 char *result = 0 ;
28554
28555 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28556 {
28557 PyThreadState* __tstate = wxPyBeginAllowThreads();
28558 result = (char *)wxGetDefaultPyEncoding();
28559 wxPyEndAllowThreads(__tstate);
28560 if (PyErr_Occurred()) SWIG_fail;
28561 }
28562 resultobj = SWIG_FromCharPtr(result);
28563 return resultobj;
28564 fail:
28565 return NULL;
28566 }
28567
28568
28569 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28570 PyObject *resultobj = 0;
28571 wxEventLoop *result = 0 ;
28572
28573 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28574 {
28575 PyThreadState* __tstate = wxPyBeginAllowThreads();
28576 result = (wxEventLoop *)new wxEventLoop();
28577 wxPyEndAllowThreads(__tstate);
28578 if (PyErr_Occurred()) SWIG_fail;
28579 }
28580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28581 return resultobj;
28582 fail:
28583 return NULL;
28584 }
28585
28586
28587 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28588 PyObject *resultobj = 0;
28589 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28590 void *argp1 = 0 ;
28591 int res1 = 0 ;
28592 PyObject *swig_obj[1] ;
28593
28594 if (!args) SWIG_fail;
28595 swig_obj[0] = args;
28596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28597 if (!SWIG_IsOK(res1)) {
28598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28599 }
28600 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28601 {
28602 PyThreadState* __tstate = wxPyBeginAllowThreads();
28603 delete arg1;
28604
28605 wxPyEndAllowThreads(__tstate);
28606 if (PyErr_Occurred()) SWIG_fail;
28607 }
28608 resultobj = SWIG_Py_Void();
28609 return resultobj;
28610 fail:
28611 return NULL;
28612 }
28613
28614
28615 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28616 PyObject *resultobj = 0;
28617 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28618 int result;
28619 void *argp1 = 0 ;
28620 int res1 = 0 ;
28621 PyObject *swig_obj[1] ;
28622
28623 if (!args) SWIG_fail;
28624 swig_obj[0] = args;
28625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28626 if (!SWIG_IsOK(res1)) {
28627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28628 }
28629 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28630 {
28631 PyThreadState* __tstate = wxPyBeginAllowThreads();
28632 result = (int)(arg1)->Run();
28633 wxPyEndAllowThreads(__tstate);
28634 if (PyErr_Occurred()) SWIG_fail;
28635 }
28636 resultobj = SWIG_From_int(static_cast< int >(result));
28637 return resultobj;
28638 fail:
28639 return NULL;
28640 }
28641
28642
28643 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28644 PyObject *resultobj = 0;
28645 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28646 int arg2 = (int) 0 ;
28647 void *argp1 = 0 ;
28648 int res1 = 0 ;
28649 int val2 ;
28650 int ecode2 = 0 ;
28651 PyObject * obj0 = 0 ;
28652 PyObject * obj1 = 0 ;
28653 char * kwnames[] = {
28654 (char *) "self",(char *) "rc", NULL
28655 };
28656
28657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28659 if (!SWIG_IsOK(res1)) {
28660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28661 }
28662 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28663 if (obj1) {
28664 ecode2 = SWIG_AsVal_int(obj1, &val2);
28665 if (!SWIG_IsOK(ecode2)) {
28666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28667 }
28668 arg2 = static_cast< int >(val2);
28669 }
28670 {
28671 PyThreadState* __tstate = wxPyBeginAllowThreads();
28672 (arg1)->Exit(arg2);
28673 wxPyEndAllowThreads(__tstate);
28674 if (PyErr_Occurred()) SWIG_fail;
28675 }
28676 resultobj = SWIG_Py_Void();
28677 return resultobj;
28678 fail:
28679 return NULL;
28680 }
28681
28682
28683 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28684 PyObject *resultobj = 0;
28685 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28686 bool result;
28687 void *argp1 = 0 ;
28688 int res1 = 0 ;
28689 PyObject *swig_obj[1] ;
28690
28691 if (!args) SWIG_fail;
28692 swig_obj[0] = args;
28693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28694 if (!SWIG_IsOK(res1)) {
28695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28696 }
28697 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28698 {
28699 PyThreadState* __tstate = wxPyBeginAllowThreads();
28700 result = (bool)((wxEventLoop const *)arg1)->Pending();
28701 wxPyEndAllowThreads(__tstate);
28702 if (PyErr_Occurred()) SWIG_fail;
28703 }
28704 {
28705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28706 }
28707 return resultobj;
28708 fail:
28709 return NULL;
28710 }
28711
28712
28713 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28714 PyObject *resultobj = 0;
28715 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28716 bool result;
28717 void *argp1 = 0 ;
28718 int res1 = 0 ;
28719 PyObject *swig_obj[1] ;
28720
28721 if (!args) SWIG_fail;
28722 swig_obj[0] = args;
28723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28724 if (!SWIG_IsOK(res1)) {
28725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28726 }
28727 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28728 {
28729 PyThreadState* __tstate = wxPyBeginAllowThreads();
28730 result = (bool)(arg1)->Dispatch();
28731 wxPyEndAllowThreads(__tstate);
28732 if (PyErr_Occurred()) SWIG_fail;
28733 }
28734 {
28735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28736 }
28737 return resultobj;
28738 fail:
28739 return NULL;
28740 }
28741
28742
28743 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28744 PyObject *resultobj = 0;
28745 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28746 bool result;
28747 void *argp1 = 0 ;
28748 int res1 = 0 ;
28749 PyObject *swig_obj[1] ;
28750
28751 if (!args) SWIG_fail;
28752 swig_obj[0] = args;
28753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28754 if (!SWIG_IsOK(res1)) {
28755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28756 }
28757 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28758 {
28759 PyThreadState* __tstate = wxPyBeginAllowThreads();
28760 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28761 wxPyEndAllowThreads(__tstate);
28762 if (PyErr_Occurred()) SWIG_fail;
28763 }
28764 {
28765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28766 }
28767 return resultobj;
28768 fail:
28769 return NULL;
28770 }
28771
28772
28773 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28774 PyObject *resultobj = 0;
28775 wxEventLoop *result = 0 ;
28776
28777 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28778 {
28779 PyThreadState* __tstate = wxPyBeginAllowThreads();
28780 result = (wxEventLoop *)wxEventLoop::GetActive();
28781 wxPyEndAllowThreads(__tstate);
28782 if (PyErr_Occurred()) SWIG_fail;
28783 }
28784 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28785 return resultobj;
28786 fail:
28787 return NULL;
28788 }
28789
28790
28791 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28792 PyObject *resultobj = 0;
28793 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28794 void *argp1 = 0 ;
28795 int res1 = 0 ;
28796 PyObject * obj0 = 0 ;
28797 char * kwnames[] = {
28798 (char *) "loop", NULL
28799 };
28800
28801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28803 if (!SWIG_IsOK(res1)) {
28804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28805 }
28806 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28807 {
28808 PyThreadState* __tstate = wxPyBeginAllowThreads();
28809 wxEventLoop::SetActive(arg1);
28810 wxPyEndAllowThreads(__tstate);
28811 if (PyErr_Occurred()) SWIG_fail;
28812 }
28813 resultobj = SWIG_Py_Void();
28814 return resultobj;
28815 fail:
28816 return NULL;
28817 }
28818
28819
28820 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28821 PyObject *obj;
28822 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28823 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28824 return SWIG_Py_Void();
28825 }
28826
28827 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28828 return SWIG_Python_InitShadowInstance(args);
28829 }
28830
28831 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28832 PyObject *resultobj = 0;
28833 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28834 wxEventLoopActivator *result = 0 ;
28835 void *argp1 = 0 ;
28836 int res1 = 0 ;
28837 PyObject * obj0 = 0 ;
28838 char * kwnames[] = {
28839 (char *) "evtLoop", NULL
28840 };
28841
28842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28844 if (!SWIG_IsOK(res1)) {
28845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28846 }
28847 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28848 {
28849 PyThreadState* __tstate = wxPyBeginAllowThreads();
28850 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28851 wxPyEndAllowThreads(__tstate);
28852 if (PyErr_Occurred()) SWIG_fail;
28853 }
28854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28855 return resultobj;
28856 fail:
28857 return NULL;
28858 }
28859
28860
28861 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28862 PyObject *resultobj = 0;
28863 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28864 void *argp1 = 0 ;
28865 int res1 = 0 ;
28866 PyObject *swig_obj[1] ;
28867
28868 if (!args) SWIG_fail;
28869 swig_obj[0] = args;
28870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28871 if (!SWIG_IsOK(res1)) {
28872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28873 }
28874 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28875 {
28876 PyThreadState* __tstate = wxPyBeginAllowThreads();
28877 delete arg1;
28878
28879 wxPyEndAllowThreads(__tstate);
28880 if (PyErr_Occurred()) SWIG_fail;
28881 }
28882 resultobj = SWIG_Py_Void();
28883 return resultobj;
28884 fail:
28885 return NULL;
28886 }
28887
28888
28889 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28890 PyObject *obj;
28891 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28892 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28893 return SWIG_Py_Void();
28894 }
28895
28896 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28897 return SWIG_Python_InitShadowInstance(args);
28898 }
28899
28900 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28901 PyObject *resultobj = 0;
28902 int arg1 = (int) 0 ;
28903 int arg2 = (int) 0 ;
28904 int arg3 = (int) 0 ;
28905 wxAcceleratorEntry *result = 0 ;
28906 int val1 ;
28907 int ecode1 = 0 ;
28908 int val2 ;
28909 int ecode2 = 0 ;
28910 int val3 ;
28911 int ecode3 = 0 ;
28912 PyObject * obj0 = 0 ;
28913 PyObject * obj1 = 0 ;
28914 PyObject * obj2 = 0 ;
28915 char * kwnames[] = {
28916 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28917 };
28918
28919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28920 if (obj0) {
28921 ecode1 = SWIG_AsVal_int(obj0, &val1);
28922 if (!SWIG_IsOK(ecode1)) {
28923 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28924 }
28925 arg1 = static_cast< int >(val1);
28926 }
28927 if (obj1) {
28928 ecode2 = SWIG_AsVal_int(obj1, &val2);
28929 if (!SWIG_IsOK(ecode2)) {
28930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28931 }
28932 arg2 = static_cast< int >(val2);
28933 }
28934 if (obj2) {
28935 ecode3 = SWIG_AsVal_int(obj2, &val3);
28936 if (!SWIG_IsOK(ecode3)) {
28937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28938 }
28939 arg3 = static_cast< int >(val3);
28940 }
28941 {
28942 PyThreadState* __tstate = wxPyBeginAllowThreads();
28943 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28944 wxPyEndAllowThreads(__tstate);
28945 if (PyErr_Occurred()) SWIG_fail;
28946 }
28947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28948 return resultobj;
28949 fail:
28950 return NULL;
28951 }
28952
28953
28954 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28955 PyObject *resultobj = 0;
28956 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28957 void *argp1 = 0 ;
28958 int res1 = 0 ;
28959 PyObject *swig_obj[1] ;
28960
28961 if (!args) SWIG_fail;
28962 swig_obj[0] = args;
28963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28964 if (!SWIG_IsOK(res1)) {
28965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28966 }
28967 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28968 {
28969 PyThreadState* __tstate = wxPyBeginAllowThreads();
28970 delete arg1;
28971
28972 wxPyEndAllowThreads(__tstate);
28973 if (PyErr_Occurred()) SWIG_fail;
28974 }
28975 resultobj = SWIG_Py_Void();
28976 return resultobj;
28977 fail:
28978 return NULL;
28979 }
28980
28981
28982 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28983 PyObject *resultobj = 0;
28984 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28985 int arg2 ;
28986 int arg3 ;
28987 int arg4 ;
28988 void *argp1 = 0 ;
28989 int res1 = 0 ;
28990 int val2 ;
28991 int ecode2 = 0 ;
28992 int val3 ;
28993 int ecode3 = 0 ;
28994 int val4 ;
28995 int ecode4 = 0 ;
28996 PyObject * obj0 = 0 ;
28997 PyObject * obj1 = 0 ;
28998 PyObject * obj2 = 0 ;
28999 PyObject * obj3 = 0 ;
29000 char * kwnames[] = {
29001 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29002 };
29003
29004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29006 if (!SWIG_IsOK(res1)) {
29007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29008 }
29009 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29010 ecode2 = SWIG_AsVal_int(obj1, &val2);
29011 if (!SWIG_IsOK(ecode2)) {
29012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29013 }
29014 arg2 = static_cast< int >(val2);
29015 ecode3 = SWIG_AsVal_int(obj2, &val3);
29016 if (!SWIG_IsOK(ecode3)) {
29017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29018 }
29019 arg3 = static_cast< int >(val3);
29020 ecode4 = SWIG_AsVal_int(obj3, &val4);
29021 if (!SWIG_IsOK(ecode4)) {
29022 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29023 }
29024 arg4 = static_cast< int >(val4);
29025 {
29026 PyThreadState* __tstate = wxPyBeginAllowThreads();
29027 (arg1)->Set(arg2,arg3,arg4);
29028 wxPyEndAllowThreads(__tstate);
29029 if (PyErr_Occurred()) SWIG_fail;
29030 }
29031 resultobj = SWIG_Py_Void();
29032 return resultobj;
29033 fail:
29034 return NULL;
29035 }
29036
29037
29038 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29039 PyObject *resultobj = 0;
29040 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29041 int result;
29042 void *argp1 = 0 ;
29043 int res1 = 0 ;
29044 PyObject *swig_obj[1] ;
29045
29046 if (!args) SWIG_fail;
29047 swig_obj[0] = args;
29048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29049 if (!SWIG_IsOK(res1)) {
29050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29051 }
29052 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29053 {
29054 PyThreadState* __tstate = wxPyBeginAllowThreads();
29055 result = (int)(arg1)->GetFlags();
29056 wxPyEndAllowThreads(__tstate);
29057 if (PyErr_Occurred()) SWIG_fail;
29058 }
29059 resultobj = SWIG_From_int(static_cast< int >(result));
29060 return resultobj;
29061 fail:
29062 return NULL;
29063 }
29064
29065
29066 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29067 PyObject *resultobj = 0;
29068 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29069 int result;
29070 void *argp1 = 0 ;
29071 int res1 = 0 ;
29072 PyObject *swig_obj[1] ;
29073
29074 if (!args) SWIG_fail;
29075 swig_obj[0] = args;
29076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29077 if (!SWIG_IsOK(res1)) {
29078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29079 }
29080 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29081 {
29082 PyThreadState* __tstate = wxPyBeginAllowThreads();
29083 result = (int)(arg1)->GetKeyCode();
29084 wxPyEndAllowThreads(__tstate);
29085 if (PyErr_Occurred()) SWIG_fail;
29086 }
29087 resultobj = SWIG_From_int(static_cast< int >(result));
29088 return resultobj;
29089 fail:
29090 return NULL;
29091 }
29092
29093
29094 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29095 PyObject *resultobj = 0;
29096 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29097 int result;
29098 void *argp1 = 0 ;
29099 int res1 = 0 ;
29100 PyObject *swig_obj[1] ;
29101
29102 if (!args) SWIG_fail;
29103 swig_obj[0] = args;
29104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29105 if (!SWIG_IsOK(res1)) {
29106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29107 }
29108 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29109 {
29110 PyThreadState* __tstate = wxPyBeginAllowThreads();
29111 result = (int)(arg1)->GetCommand();
29112 wxPyEndAllowThreads(__tstate);
29113 if (PyErr_Occurred()) SWIG_fail;
29114 }
29115 resultobj = SWIG_From_int(static_cast< int >(result));
29116 return resultobj;
29117 fail:
29118 return NULL;
29119 }
29120
29121
29122 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29123 PyObject *obj;
29124 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29125 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29126 return SWIG_Py_Void();
29127 }
29128
29129 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29130 return SWIG_Python_InitShadowInstance(args);
29131 }
29132
29133 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29134 PyObject *resultobj = 0;
29135 int arg1 ;
29136 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29137 wxAcceleratorTable *result = 0 ;
29138 PyObject * obj0 = 0 ;
29139 char * kwnames[] = {
29140 (char *) "n", NULL
29141 };
29142
29143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29144 {
29145 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29146 if (arg2) arg1 = PyList_Size(obj0);
29147 else arg1 = 0;
29148 }
29149 {
29150 PyThreadState* __tstate = wxPyBeginAllowThreads();
29151 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29152 wxPyEndAllowThreads(__tstate);
29153 if (PyErr_Occurred()) SWIG_fail;
29154 }
29155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29156 return resultobj;
29157 fail:
29158 return NULL;
29159 }
29160
29161
29162 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29163 PyObject *resultobj = 0;
29164 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29165 void *argp1 = 0 ;
29166 int res1 = 0 ;
29167 PyObject *swig_obj[1] ;
29168
29169 if (!args) SWIG_fail;
29170 swig_obj[0] = args;
29171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29172 if (!SWIG_IsOK(res1)) {
29173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29174 }
29175 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29176 {
29177 PyThreadState* __tstate = wxPyBeginAllowThreads();
29178 delete arg1;
29179
29180 wxPyEndAllowThreads(__tstate);
29181 if (PyErr_Occurred()) SWIG_fail;
29182 }
29183 resultobj = SWIG_Py_Void();
29184 return resultobj;
29185 fail:
29186 return NULL;
29187 }
29188
29189
29190 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29191 PyObject *resultobj = 0;
29192 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29193 bool result;
29194 void *argp1 = 0 ;
29195 int res1 = 0 ;
29196 PyObject *swig_obj[1] ;
29197
29198 if (!args) SWIG_fail;
29199 swig_obj[0] = args;
29200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29201 if (!SWIG_IsOK(res1)) {
29202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29203 }
29204 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29205 {
29206 PyThreadState* __tstate = wxPyBeginAllowThreads();
29207 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29208 wxPyEndAllowThreads(__tstate);
29209 if (PyErr_Occurred()) SWIG_fail;
29210 }
29211 {
29212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29213 }
29214 return resultobj;
29215 fail:
29216 return NULL;
29217 }
29218
29219
29220 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29221 PyObject *obj;
29222 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29223 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29224 return SWIG_Py_Void();
29225 }
29226
29227 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29228 return SWIG_Python_InitShadowInstance(args);
29229 }
29230
29231 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29232 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29233 return 1;
29234 }
29235
29236
29237 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29238 PyObject *pyobj = 0;
29239
29240 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29241 return pyobj;
29242 }
29243
29244
29245 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29246 PyObject *resultobj = 0;
29247 wxString *arg1 = 0 ;
29248 wxAcceleratorEntry *result = 0 ;
29249 bool temp1 = false ;
29250 PyObject * obj0 = 0 ;
29251 char * kwnames[] = {
29252 (char *) "label", NULL
29253 };
29254
29255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29256 {
29257 arg1 = wxString_in_helper(obj0);
29258 if (arg1 == NULL) SWIG_fail;
29259 temp1 = true;
29260 }
29261 {
29262 PyThreadState* __tstate = wxPyBeginAllowThreads();
29263 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29264 wxPyEndAllowThreads(__tstate);
29265 if (PyErr_Occurred()) SWIG_fail;
29266 }
29267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29268 {
29269 if (temp1)
29270 delete arg1;
29271 }
29272 return resultobj;
29273 fail:
29274 {
29275 if (temp1)
29276 delete arg1;
29277 }
29278 return NULL;
29279 }
29280
29281
29282 SWIGINTERN int PanelNameStr_set(PyObject *) {
29283 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29284 return 1;
29285 }
29286
29287
29288 SWIGINTERN PyObject *PanelNameStr_get(void) {
29289 PyObject *pyobj = 0;
29290
29291 {
29292 #if wxUSE_UNICODE
29293 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29294 #else
29295 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29296 #endif
29297 }
29298 return pyobj;
29299 }
29300
29301
29302 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29303 PyObject *resultobj = 0;
29304 wxVisualAttributes *result = 0 ;
29305
29306 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29307 {
29308 PyThreadState* __tstate = wxPyBeginAllowThreads();
29309 result = (wxVisualAttributes *)new_wxVisualAttributes();
29310 wxPyEndAllowThreads(__tstate);
29311 if (PyErr_Occurred()) SWIG_fail;
29312 }
29313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29314 return resultobj;
29315 fail:
29316 return NULL;
29317 }
29318
29319
29320 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29321 PyObject *resultobj = 0;
29322 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29323 void *argp1 = 0 ;
29324 int res1 = 0 ;
29325 PyObject *swig_obj[1] ;
29326
29327 if (!args) SWIG_fail;
29328 swig_obj[0] = args;
29329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29330 if (!SWIG_IsOK(res1)) {
29331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29332 }
29333 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29334 {
29335 PyThreadState* __tstate = wxPyBeginAllowThreads();
29336 delete_wxVisualAttributes(arg1);
29337
29338 wxPyEndAllowThreads(__tstate);
29339 if (PyErr_Occurred()) SWIG_fail;
29340 }
29341 resultobj = SWIG_Py_Void();
29342 return resultobj;
29343 fail:
29344 return NULL;
29345 }
29346
29347
29348 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29349 PyObject *resultobj = 0;
29350 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29351 wxFont *arg2 = (wxFont *) 0 ;
29352 void *argp1 = 0 ;
29353 int res1 = 0 ;
29354 void *argp2 = 0 ;
29355 int res2 = 0 ;
29356 PyObject *swig_obj[2] ;
29357
29358 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29360 if (!SWIG_IsOK(res1)) {
29361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29362 }
29363 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29364 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29365 if (!SWIG_IsOK(res2)) {
29366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29367 }
29368 arg2 = reinterpret_cast< wxFont * >(argp2);
29369 if (arg1) (arg1)->font = *arg2;
29370
29371 resultobj = SWIG_Py_Void();
29372 return resultobj;
29373 fail:
29374 return NULL;
29375 }
29376
29377
29378 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29379 PyObject *resultobj = 0;
29380 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29381 wxFont *result = 0 ;
29382 void *argp1 = 0 ;
29383 int res1 = 0 ;
29384 PyObject *swig_obj[1] ;
29385
29386 if (!args) SWIG_fail;
29387 swig_obj[0] = args;
29388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29389 if (!SWIG_IsOK(res1)) {
29390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29391 }
29392 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29393 result = (wxFont *)& ((arg1)->font);
29394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29395 return resultobj;
29396 fail:
29397 return NULL;
29398 }
29399
29400
29401 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29402 PyObject *resultobj = 0;
29403 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29404 wxColour *arg2 = (wxColour *) 0 ;
29405 void *argp1 = 0 ;
29406 int res1 = 0 ;
29407 void *argp2 = 0 ;
29408 int res2 = 0 ;
29409 PyObject *swig_obj[2] ;
29410
29411 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29413 if (!SWIG_IsOK(res1)) {
29414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29415 }
29416 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29417 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29418 if (!SWIG_IsOK(res2)) {
29419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29420 }
29421 arg2 = reinterpret_cast< wxColour * >(argp2);
29422 if (arg1) (arg1)->colFg = *arg2;
29423
29424 resultobj = SWIG_Py_Void();
29425 return resultobj;
29426 fail:
29427 return NULL;
29428 }
29429
29430
29431 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29432 PyObject *resultobj = 0;
29433 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29434 wxColour *result = 0 ;
29435 void *argp1 = 0 ;
29436 int res1 = 0 ;
29437 PyObject *swig_obj[1] ;
29438
29439 if (!args) SWIG_fail;
29440 swig_obj[0] = args;
29441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29442 if (!SWIG_IsOK(res1)) {
29443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29444 }
29445 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29446 result = (wxColour *)& ((arg1)->colFg);
29447 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29448 return resultobj;
29449 fail:
29450 return NULL;
29451 }
29452
29453
29454 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29455 PyObject *resultobj = 0;
29456 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29457 wxColour *arg2 = (wxColour *) 0 ;
29458 void *argp1 = 0 ;
29459 int res1 = 0 ;
29460 void *argp2 = 0 ;
29461 int res2 = 0 ;
29462 PyObject *swig_obj[2] ;
29463
29464 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29466 if (!SWIG_IsOK(res1)) {
29467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29468 }
29469 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29470 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29471 if (!SWIG_IsOK(res2)) {
29472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29473 }
29474 arg2 = reinterpret_cast< wxColour * >(argp2);
29475 if (arg1) (arg1)->colBg = *arg2;
29476
29477 resultobj = SWIG_Py_Void();
29478 return resultobj;
29479 fail:
29480 return NULL;
29481 }
29482
29483
29484 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29485 PyObject *resultobj = 0;
29486 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29487 wxColour *result = 0 ;
29488 void *argp1 = 0 ;
29489 int res1 = 0 ;
29490 PyObject *swig_obj[1] ;
29491
29492 if (!args) SWIG_fail;
29493 swig_obj[0] = args;
29494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29495 if (!SWIG_IsOK(res1)) {
29496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29497 }
29498 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29499 result = (wxColour *)& ((arg1)->colBg);
29500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29501 return resultobj;
29502 fail:
29503 return NULL;
29504 }
29505
29506
29507 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29508 PyObject *obj;
29509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29510 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29511 return SWIG_Py_Void();
29512 }
29513
29514 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29515 return SWIG_Python_InitShadowInstance(args);
29516 }
29517
29518 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29519 PyObject *resultobj = 0;
29520 wxWindow *arg1 = (wxWindow *) 0 ;
29521 int arg2 = (int) (int)-1 ;
29522 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29523 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29524 wxSize const &arg4_defvalue = wxDefaultSize ;
29525 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29526 long arg5 = (long) 0 ;
29527 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29528 wxString *arg6 = (wxString *) &arg6_defvalue ;
29529 wxWindow *result = 0 ;
29530 void *argp1 = 0 ;
29531 int res1 = 0 ;
29532 int val2 ;
29533 int ecode2 = 0 ;
29534 wxPoint temp3 ;
29535 wxSize temp4 ;
29536 long val5 ;
29537 int ecode5 = 0 ;
29538 bool temp6 = false ;
29539 PyObject * obj0 = 0 ;
29540 PyObject * obj1 = 0 ;
29541 PyObject * obj2 = 0 ;
29542 PyObject * obj3 = 0 ;
29543 PyObject * obj4 = 0 ;
29544 PyObject * obj5 = 0 ;
29545 char * kwnames[] = {
29546 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29547 };
29548
29549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29551 if (!SWIG_IsOK(res1)) {
29552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29553 }
29554 arg1 = reinterpret_cast< wxWindow * >(argp1);
29555 if (obj1) {
29556 ecode2 = SWIG_AsVal_int(obj1, &val2);
29557 if (!SWIG_IsOK(ecode2)) {
29558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29559 }
29560 arg2 = static_cast< int >(val2);
29561 }
29562 if (obj2) {
29563 {
29564 arg3 = &temp3;
29565 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29566 }
29567 }
29568 if (obj3) {
29569 {
29570 arg4 = &temp4;
29571 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29572 }
29573 }
29574 if (obj4) {
29575 ecode5 = SWIG_AsVal_long(obj4, &val5);
29576 if (!SWIG_IsOK(ecode5)) {
29577 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29578 }
29579 arg5 = static_cast< long >(val5);
29580 }
29581 if (obj5) {
29582 {
29583 arg6 = wxString_in_helper(obj5);
29584 if (arg6 == NULL) SWIG_fail;
29585 temp6 = true;
29586 }
29587 }
29588 {
29589 if (!wxPyCheckForApp()) SWIG_fail;
29590 PyThreadState* __tstate = wxPyBeginAllowThreads();
29591 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29592 wxPyEndAllowThreads(__tstate);
29593 if (PyErr_Occurred()) SWIG_fail;
29594 }
29595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29596 {
29597 if (temp6)
29598 delete arg6;
29599 }
29600 return resultobj;
29601 fail:
29602 {
29603 if (temp6)
29604 delete arg6;
29605 }
29606 return NULL;
29607 }
29608
29609
29610 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29611 PyObject *resultobj = 0;
29612 wxWindow *result = 0 ;
29613
29614 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29615 {
29616 if (!wxPyCheckForApp()) SWIG_fail;
29617 PyThreadState* __tstate = wxPyBeginAllowThreads();
29618 result = (wxWindow *)new wxWindow();
29619 wxPyEndAllowThreads(__tstate);
29620 if (PyErr_Occurred()) SWIG_fail;
29621 }
29622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29623 return resultobj;
29624 fail:
29625 return NULL;
29626 }
29627
29628
29629 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29630 PyObject *resultobj = 0;
29631 wxWindow *arg1 = (wxWindow *) 0 ;
29632 wxWindow *arg2 = (wxWindow *) 0 ;
29633 int arg3 = (int) (int)-1 ;
29634 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29635 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29636 wxSize const &arg5_defvalue = wxDefaultSize ;
29637 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29638 long arg6 = (long) 0 ;
29639 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29640 wxString *arg7 = (wxString *) &arg7_defvalue ;
29641 bool result;
29642 void *argp1 = 0 ;
29643 int res1 = 0 ;
29644 void *argp2 = 0 ;
29645 int res2 = 0 ;
29646 int val3 ;
29647 int ecode3 = 0 ;
29648 wxPoint temp4 ;
29649 wxSize temp5 ;
29650 long val6 ;
29651 int ecode6 = 0 ;
29652 bool temp7 = false ;
29653 PyObject * obj0 = 0 ;
29654 PyObject * obj1 = 0 ;
29655 PyObject * obj2 = 0 ;
29656 PyObject * obj3 = 0 ;
29657 PyObject * obj4 = 0 ;
29658 PyObject * obj5 = 0 ;
29659 PyObject * obj6 = 0 ;
29660 char * kwnames[] = {
29661 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29662 };
29663
29664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29666 if (!SWIG_IsOK(res1)) {
29667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29668 }
29669 arg1 = reinterpret_cast< wxWindow * >(argp1);
29670 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29671 if (!SWIG_IsOK(res2)) {
29672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29673 }
29674 arg2 = reinterpret_cast< wxWindow * >(argp2);
29675 if (obj2) {
29676 ecode3 = SWIG_AsVal_int(obj2, &val3);
29677 if (!SWIG_IsOK(ecode3)) {
29678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29679 }
29680 arg3 = static_cast< int >(val3);
29681 }
29682 if (obj3) {
29683 {
29684 arg4 = &temp4;
29685 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29686 }
29687 }
29688 if (obj4) {
29689 {
29690 arg5 = &temp5;
29691 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29692 }
29693 }
29694 if (obj5) {
29695 ecode6 = SWIG_AsVal_long(obj5, &val6);
29696 if (!SWIG_IsOK(ecode6)) {
29697 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29698 }
29699 arg6 = static_cast< long >(val6);
29700 }
29701 if (obj6) {
29702 {
29703 arg7 = wxString_in_helper(obj6);
29704 if (arg7 == NULL) SWIG_fail;
29705 temp7 = true;
29706 }
29707 }
29708 {
29709 PyThreadState* __tstate = wxPyBeginAllowThreads();
29710 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29711 wxPyEndAllowThreads(__tstate);
29712 if (PyErr_Occurred()) SWIG_fail;
29713 }
29714 {
29715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29716 }
29717 {
29718 if (temp7)
29719 delete arg7;
29720 }
29721 return resultobj;
29722 fail:
29723 {
29724 if (temp7)
29725 delete arg7;
29726 }
29727 return NULL;
29728 }
29729
29730
29731 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29732 PyObject *resultobj = 0;
29733 wxWindow *arg1 = (wxWindow *) 0 ;
29734 bool arg2 = (bool) false ;
29735 bool result;
29736 void *argp1 = 0 ;
29737 int res1 = 0 ;
29738 bool val2 ;
29739 int ecode2 = 0 ;
29740 PyObject * obj0 = 0 ;
29741 PyObject * obj1 = 0 ;
29742 char * kwnames[] = {
29743 (char *) "self",(char *) "force", NULL
29744 };
29745
29746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29748 if (!SWIG_IsOK(res1)) {
29749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29750 }
29751 arg1 = reinterpret_cast< wxWindow * >(argp1);
29752 if (obj1) {
29753 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29754 if (!SWIG_IsOK(ecode2)) {
29755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29756 }
29757 arg2 = static_cast< bool >(val2);
29758 }
29759 {
29760 PyThreadState* __tstate = wxPyBeginAllowThreads();
29761 result = (bool)(arg1)->Close(arg2);
29762 wxPyEndAllowThreads(__tstate);
29763 if (PyErr_Occurred()) SWIG_fail;
29764 }
29765 {
29766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29767 }
29768 return resultobj;
29769 fail:
29770 return NULL;
29771 }
29772
29773
29774 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29775 PyObject *resultobj = 0;
29776 wxWindow *arg1 = (wxWindow *) 0 ;
29777 bool result;
29778 void *argp1 = 0 ;
29779 int res1 = 0 ;
29780 PyObject *swig_obj[1] ;
29781
29782 if (!args) SWIG_fail;
29783 swig_obj[0] = args;
29784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29785 if (!SWIG_IsOK(res1)) {
29786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29787 }
29788 arg1 = reinterpret_cast< wxWindow * >(argp1);
29789 {
29790 PyThreadState* __tstate = wxPyBeginAllowThreads();
29791 result = (bool)(arg1)->Destroy();
29792 wxPyEndAllowThreads(__tstate);
29793 if (PyErr_Occurred()) SWIG_fail;
29794 }
29795 {
29796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29797 }
29798 return resultobj;
29799 fail:
29800 return NULL;
29801 }
29802
29803
29804 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29805 PyObject *resultobj = 0;
29806 wxWindow *arg1 = (wxWindow *) 0 ;
29807 bool result;
29808 void *argp1 = 0 ;
29809 int res1 = 0 ;
29810 PyObject *swig_obj[1] ;
29811
29812 if (!args) SWIG_fail;
29813 swig_obj[0] = args;
29814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29815 if (!SWIG_IsOK(res1)) {
29816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29817 }
29818 arg1 = reinterpret_cast< wxWindow * >(argp1);
29819 {
29820 PyThreadState* __tstate = wxPyBeginAllowThreads();
29821 result = (bool)(arg1)->DestroyChildren();
29822 wxPyEndAllowThreads(__tstate);
29823 if (PyErr_Occurred()) SWIG_fail;
29824 }
29825 {
29826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29827 }
29828 return resultobj;
29829 fail:
29830 return NULL;
29831 }
29832
29833
29834 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29835 PyObject *resultobj = 0;
29836 wxWindow *arg1 = (wxWindow *) 0 ;
29837 bool result;
29838 void *argp1 = 0 ;
29839 int res1 = 0 ;
29840 PyObject *swig_obj[1] ;
29841
29842 if (!args) SWIG_fail;
29843 swig_obj[0] = args;
29844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29845 if (!SWIG_IsOK(res1)) {
29846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29847 }
29848 arg1 = reinterpret_cast< wxWindow * >(argp1);
29849 {
29850 PyThreadState* __tstate = wxPyBeginAllowThreads();
29851 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29852 wxPyEndAllowThreads(__tstate);
29853 if (PyErr_Occurred()) SWIG_fail;
29854 }
29855 {
29856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29857 }
29858 return resultobj;
29859 fail:
29860 return NULL;
29861 }
29862
29863
29864 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29865 PyObject *resultobj = 0;
29866 wxWindow *arg1 = (wxWindow *) 0 ;
29867 wxString *arg2 = 0 ;
29868 void *argp1 = 0 ;
29869 int res1 = 0 ;
29870 bool temp2 = false ;
29871 PyObject * obj0 = 0 ;
29872 PyObject * obj1 = 0 ;
29873 char * kwnames[] = {
29874 (char *) "self",(char *) "label", NULL
29875 };
29876
29877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29879 if (!SWIG_IsOK(res1)) {
29880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29881 }
29882 arg1 = reinterpret_cast< wxWindow * >(argp1);
29883 {
29884 arg2 = wxString_in_helper(obj1);
29885 if (arg2 == NULL) SWIG_fail;
29886 temp2 = true;
29887 }
29888 {
29889 PyThreadState* __tstate = wxPyBeginAllowThreads();
29890 (arg1)->SetLabel((wxString const &)*arg2);
29891 wxPyEndAllowThreads(__tstate);
29892 if (PyErr_Occurred()) SWIG_fail;
29893 }
29894 resultobj = SWIG_Py_Void();
29895 {
29896 if (temp2)
29897 delete arg2;
29898 }
29899 return resultobj;
29900 fail:
29901 {
29902 if (temp2)
29903 delete arg2;
29904 }
29905 return NULL;
29906 }
29907
29908
29909 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29910 PyObject *resultobj = 0;
29911 wxWindow *arg1 = (wxWindow *) 0 ;
29912 wxString result;
29913 void *argp1 = 0 ;
29914 int res1 = 0 ;
29915 PyObject *swig_obj[1] ;
29916
29917 if (!args) SWIG_fail;
29918 swig_obj[0] = args;
29919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29920 if (!SWIG_IsOK(res1)) {
29921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29922 }
29923 arg1 = reinterpret_cast< wxWindow * >(argp1);
29924 {
29925 PyThreadState* __tstate = wxPyBeginAllowThreads();
29926 result = ((wxWindow const *)arg1)->GetLabel();
29927 wxPyEndAllowThreads(__tstate);
29928 if (PyErr_Occurred()) SWIG_fail;
29929 }
29930 {
29931 #if wxUSE_UNICODE
29932 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29933 #else
29934 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29935 #endif
29936 }
29937 return resultobj;
29938 fail:
29939 return NULL;
29940 }
29941
29942
29943 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29944 PyObject *resultobj = 0;
29945 wxWindow *arg1 = (wxWindow *) 0 ;
29946 wxString *arg2 = 0 ;
29947 void *argp1 = 0 ;
29948 int res1 = 0 ;
29949 bool temp2 = false ;
29950 PyObject * obj0 = 0 ;
29951 PyObject * obj1 = 0 ;
29952 char * kwnames[] = {
29953 (char *) "self",(char *) "name", NULL
29954 };
29955
29956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29958 if (!SWIG_IsOK(res1)) {
29959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29960 }
29961 arg1 = reinterpret_cast< wxWindow * >(argp1);
29962 {
29963 arg2 = wxString_in_helper(obj1);
29964 if (arg2 == NULL) SWIG_fail;
29965 temp2 = true;
29966 }
29967 {
29968 PyThreadState* __tstate = wxPyBeginAllowThreads();
29969 (arg1)->SetName((wxString const &)*arg2);
29970 wxPyEndAllowThreads(__tstate);
29971 if (PyErr_Occurred()) SWIG_fail;
29972 }
29973 resultobj = SWIG_Py_Void();
29974 {
29975 if (temp2)
29976 delete arg2;
29977 }
29978 return resultobj;
29979 fail:
29980 {
29981 if (temp2)
29982 delete arg2;
29983 }
29984 return NULL;
29985 }
29986
29987
29988 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29989 PyObject *resultobj = 0;
29990 wxWindow *arg1 = (wxWindow *) 0 ;
29991 wxString result;
29992 void *argp1 = 0 ;
29993 int res1 = 0 ;
29994 PyObject *swig_obj[1] ;
29995
29996 if (!args) SWIG_fail;
29997 swig_obj[0] = args;
29998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29999 if (!SWIG_IsOK(res1)) {
30000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30001 }
30002 arg1 = reinterpret_cast< wxWindow * >(argp1);
30003 {
30004 PyThreadState* __tstate = wxPyBeginAllowThreads();
30005 result = ((wxWindow const *)arg1)->GetName();
30006 wxPyEndAllowThreads(__tstate);
30007 if (PyErr_Occurred()) SWIG_fail;
30008 }
30009 {
30010 #if wxUSE_UNICODE
30011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30012 #else
30013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30014 #endif
30015 }
30016 return resultobj;
30017 fail:
30018 return NULL;
30019 }
30020
30021
30022 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30023 PyObject *resultobj = 0;
30024 wxWindow *arg1 = (wxWindow *) 0 ;
30025 wxWindowVariant arg2 ;
30026 void *argp1 = 0 ;
30027 int res1 = 0 ;
30028 int val2 ;
30029 int ecode2 = 0 ;
30030 PyObject * obj0 = 0 ;
30031 PyObject * obj1 = 0 ;
30032 char * kwnames[] = {
30033 (char *) "self",(char *) "variant", NULL
30034 };
30035
30036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30038 if (!SWIG_IsOK(res1)) {
30039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30040 }
30041 arg1 = reinterpret_cast< wxWindow * >(argp1);
30042 ecode2 = SWIG_AsVal_int(obj1, &val2);
30043 if (!SWIG_IsOK(ecode2)) {
30044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30045 }
30046 arg2 = static_cast< wxWindowVariant >(val2);
30047 {
30048 PyThreadState* __tstate = wxPyBeginAllowThreads();
30049 (arg1)->SetWindowVariant(arg2);
30050 wxPyEndAllowThreads(__tstate);
30051 if (PyErr_Occurred()) SWIG_fail;
30052 }
30053 resultobj = SWIG_Py_Void();
30054 return resultobj;
30055 fail:
30056 return NULL;
30057 }
30058
30059
30060 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30061 PyObject *resultobj = 0;
30062 wxWindow *arg1 = (wxWindow *) 0 ;
30063 wxWindowVariant result;
30064 void *argp1 = 0 ;
30065 int res1 = 0 ;
30066 PyObject *swig_obj[1] ;
30067
30068 if (!args) SWIG_fail;
30069 swig_obj[0] = args;
30070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30071 if (!SWIG_IsOK(res1)) {
30072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30073 }
30074 arg1 = reinterpret_cast< wxWindow * >(argp1);
30075 {
30076 PyThreadState* __tstate = wxPyBeginAllowThreads();
30077 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30078 wxPyEndAllowThreads(__tstate);
30079 if (PyErr_Occurred()) SWIG_fail;
30080 }
30081 resultobj = SWIG_From_int(static_cast< int >(result));
30082 return resultobj;
30083 fail:
30084 return NULL;
30085 }
30086
30087
30088 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30089 PyObject *resultobj = 0;
30090 wxWindow *arg1 = (wxWindow *) 0 ;
30091 int arg2 ;
30092 void *argp1 = 0 ;
30093 int res1 = 0 ;
30094 int val2 ;
30095 int ecode2 = 0 ;
30096 PyObject * obj0 = 0 ;
30097 PyObject * obj1 = 0 ;
30098 char * kwnames[] = {
30099 (char *) "self",(char *) "winid", NULL
30100 };
30101
30102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30104 if (!SWIG_IsOK(res1)) {
30105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30106 }
30107 arg1 = reinterpret_cast< wxWindow * >(argp1);
30108 ecode2 = SWIG_AsVal_int(obj1, &val2);
30109 if (!SWIG_IsOK(ecode2)) {
30110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30111 }
30112 arg2 = static_cast< int >(val2);
30113 {
30114 PyThreadState* __tstate = wxPyBeginAllowThreads();
30115 (arg1)->SetId(arg2);
30116 wxPyEndAllowThreads(__tstate);
30117 if (PyErr_Occurred()) SWIG_fail;
30118 }
30119 resultobj = SWIG_Py_Void();
30120 return resultobj;
30121 fail:
30122 return NULL;
30123 }
30124
30125
30126 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30127 PyObject *resultobj = 0;
30128 wxWindow *arg1 = (wxWindow *) 0 ;
30129 int result;
30130 void *argp1 = 0 ;
30131 int res1 = 0 ;
30132 PyObject *swig_obj[1] ;
30133
30134 if (!args) SWIG_fail;
30135 swig_obj[0] = args;
30136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30137 if (!SWIG_IsOK(res1)) {
30138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30139 }
30140 arg1 = reinterpret_cast< wxWindow * >(argp1);
30141 {
30142 PyThreadState* __tstate = wxPyBeginAllowThreads();
30143 result = (int)((wxWindow const *)arg1)->GetId();
30144 wxPyEndAllowThreads(__tstate);
30145 if (PyErr_Occurred()) SWIG_fail;
30146 }
30147 resultobj = SWIG_From_int(static_cast< int >(result));
30148 return resultobj;
30149 fail:
30150 return NULL;
30151 }
30152
30153
30154 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30155 PyObject *resultobj = 0;
30156 int result;
30157
30158 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30159 {
30160 PyThreadState* __tstate = wxPyBeginAllowThreads();
30161 result = (int)wxWindow::NewControlId();
30162 wxPyEndAllowThreads(__tstate);
30163 if (PyErr_Occurred()) SWIG_fail;
30164 }
30165 resultobj = SWIG_From_int(static_cast< int >(result));
30166 return resultobj;
30167 fail:
30168 return NULL;
30169 }
30170
30171
30172 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30173 PyObject *resultobj = 0;
30174 int arg1 ;
30175 int result;
30176 int val1 ;
30177 int ecode1 = 0 ;
30178 PyObject * obj0 = 0 ;
30179 char * kwnames[] = {
30180 (char *) "winid", NULL
30181 };
30182
30183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30184 ecode1 = SWIG_AsVal_int(obj0, &val1);
30185 if (!SWIG_IsOK(ecode1)) {
30186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30187 }
30188 arg1 = static_cast< int >(val1);
30189 {
30190 PyThreadState* __tstate = wxPyBeginAllowThreads();
30191 result = (int)wxWindow::NextControlId(arg1);
30192 wxPyEndAllowThreads(__tstate);
30193 if (PyErr_Occurred()) SWIG_fail;
30194 }
30195 resultobj = SWIG_From_int(static_cast< int >(result));
30196 return resultobj;
30197 fail:
30198 return NULL;
30199 }
30200
30201
30202 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30203 PyObject *resultobj = 0;
30204 int arg1 ;
30205 int result;
30206 int val1 ;
30207 int ecode1 = 0 ;
30208 PyObject * obj0 = 0 ;
30209 char * kwnames[] = {
30210 (char *) "winid", NULL
30211 };
30212
30213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30214 ecode1 = SWIG_AsVal_int(obj0, &val1);
30215 if (!SWIG_IsOK(ecode1)) {
30216 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30217 }
30218 arg1 = static_cast< int >(val1);
30219 {
30220 PyThreadState* __tstate = wxPyBeginAllowThreads();
30221 result = (int)wxWindow::PrevControlId(arg1);
30222 wxPyEndAllowThreads(__tstate);
30223 if (PyErr_Occurred()) SWIG_fail;
30224 }
30225 resultobj = SWIG_From_int(static_cast< int >(result));
30226 return resultobj;
30227 fail:
30228 return NULL;
30229 }
30230
30231
30232 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30233 PyObject *resultobj = 0;
30234 wxWindow *arg1 = (wxWindow *) 0 ;
30235 wxSize *arg2 = 0 ;
30236 void *argp1 = 0 ;
30237 int res1 = 0 ;
30238 wxSize temp2 ;
30239 PyObject * obj0 = 0 ;
30240 PyObject * obj1 = 0 ;
30241 char * kwnames[] = {
30242 (char *) "self",(char *) "size", NULL
30243 };
30244
30245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30247 if (!SWIG_IsOK(res1)) {
30248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30249 }
30250 arg1 = reinterpret_cast< wxWindow * >(argp1);
30251 {
30252 arg2 = &temp2;
30253 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30254 }
30255 {
30256 PyThreadState* __tstate = wxPyBeginAllowThreads();
30257 (arg1)->SetSize((wxSize const &)*arg2);
30258 wxPyEndAllowThreads(__tstate);
30259 if (PyErr_Occurred()) SWIG_fail;
30260 }
30261 resultobj = SWIG_Py_Void();
30262 return resultobj;
30263 fail:
30264 return NULL;
30265 }
30266
30267
30268 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30269 PyObject *resultobj = 0;
30270 wxWindow *arg1 = (wxWindow *) 0 ;
30271 int arg2 ;
30272 int arg3 ;
30273 int arg4 ;
30274 int arg5 ;
30275 int arg6 = (int) wxSIZE_AUTO ;
30276 void *argp1 = 0 ;
30277 int res1 = 0 ;
30278 int val2 ;
30279 int ecode2 = 0 ;
30280 int val3 ;
30281 int ecode3 = 0 ;
30282 int val4 ;
30283 int ecode4 = 0 ;
30284 int val5 ;
30285 int ecode5 = 0 ;
30286 int val6 ;
30287 int ecode6 = 0 ;
30288 PyObject * obj0 = 0 ;
30289 PyObject * obj1 = 0 ;
30290 PyObject * obj2 = 0 ;
30291 PyObject * obj3 = 0 ;
30292 PyObject * obj4 = 0 ;
30293 PyObject * obj5 = 0 ;
30294 char * kwnames[] = {
30295 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30296 };
30297
30298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30300 if (!SWIG_IsOK(res1)) {
30301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30302 }
30303 arg1 = reinterpret_cast< wxWindow * >(argp1);
30304 ecode2 = SWIG_AsVal_int(obj1, &val2);
30305 if (!SWIG_IsOK(ecode2)) {
30306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30307 }
30308 arg2 = static_cast< int >(val2);
30309 ecode3 = SWIG_AsVal_int(obj2, &val3);
30310 if (!SWIG_IsOK(ecode3)) {
30311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30312 }
30313 arg3 = static_cast< int >(val3);
30314 ecode4 = SWIG_AsVal_int(obj3, &val4);
30315 if (!SWIG_IsOK(ecode4)) {
30316 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30317 }
30318 arg4 = static_cast< int >(val4);
30319 ecode5 = SWIG_AsVal_int(obj4, &val5);
30320 if (!SWIG_IsOK(ecode5)) {
30321 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30322 }
30323 arg5 = static_cast< int >(val5);
30324 if (obj5) {
30325 ecode6 = SWIG_AsVal_int(obj5, &val6);
30326 if (!SWIG_IsOK(ecode6)) {
30327 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30328 }
30329 arg6 = static_cast< int >(val6);
30330 }
30331 {
30332 PyThreadState* __tstate = wxPyBeginAllowThreads();
30333 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30334 wxPyEndAllowThreads(__tstate);
30335 if (PyErr_Occurred()) SWIG_fail;
30336 }
30337 resultobj = SWIG_Py_Void();
30338 return resultobj;
30339 fail:
30340 return NULL;
30341 }
30342
30343
30344 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30345 PyObject *resultobj = 0;
30346 wxWindow *arg1 = (wxWindow *) 0 ;
30347 wxRect *arg2 = 0 ;
30348 int arg3 = (int) wxSIZE_AUTO ;
30349 void *argp1 = 0 ;
30350 int res1 = 0 ;
30351 wxRect temp2 ;
30352 int val3 ;
30353 int ecode3 = 0 ;
30354 PyObject * obj0 = 0 ;
30355 PyObject * obj1 = 0 ;
30356 PyObject * obj2 = 0 ;
30357 char * kwnames[] = {
30358 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30359 };
30360
30361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30363 if (!SWIG_IsOK(res1)) {
30364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30365 }
30366 arg1 = reinterpret_cast< wxWindow * >(argp1);
30367 {
30368 arg2 = &temp2;
30369 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30370 }
30371 if (obj2) {
30372 ecode3 = SWIG_AsVal_int(obj2, &val3);
30373 if (!SWIG_IsOK(ecode3)) {
30374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30375 }
30376 arg3 = static_cast< int >(val3);
30377 }
30378 {
30379 PyThreadState* __tstate = wxPyBeginAllowThreads();
30380 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30381 wxPyEndAllowThreads(__tstate);
30382 if (PyErr_Occurred()) SWIG_fail;
30383 }
30384 resultobj = SWIG_Py_Void();
30385 return resultobj;
30386 fail:
30387 return NULL;
30388 }
30389
30390
30391 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30392 PyObject *resultobj = 0;
30393 wxWindow *arg1 = (wxWindow *) 0 ;
30394 int arg2 ;
30395 int arg3 ;
30396 void *argp1 = 0 ;
30397 int res1 = 0 ;
30398 int val2 ;
30399 int ecode2 = 0 ;
30400 int val3 ;
30401 int ecode3 = 0 ;
30402 PyObject * obj0 = 0 ;
30403 PyObject * obj1 = 0 ;
30404 PyObject * obj2 = 0 ;
30405 char * kwnames[] = {
30406 (char *) "self",(char *) "width",(char *) "height", NULL
30407 };
30408
30409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30411 if (!SWIG_IsOK(res1)) {
30412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30413 }
30414 arg1 = reinterpret_cast< wxWindow * >(argp1);
30415 ecode2 = SWIG_AsVal_int(obj1, &val2);
30416 if (!SWIG_IsOK(ecode2)) {
30417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30418 }
30419 arg2 = static_cast< int >(val2);
30420 ecode3 = SWIG_AsVal_int(obj2, &val3);
30421 if (!SWIG_IsOK(ecode3)) {
30422 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30423 }
30424 arg3 = static_cast< int >(val3);
30425 {
30426 PyThreadState* __tstate = wxPyBeginAllowThreads();
30427 (arg1)->SetSize(arg2,arg3);
30428 wxPyEndAllowThreads(__tstate);
30429 if (PyErr_Occurred()) SWIG_fail;
30430 }
30431 resultobj = SWIG_Py_Void();
30432 return resultobj;
30433 fail:
30434 return NULL;
30435 }
30436
30437
30438 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30439 PyObject *resultobj = 0;
30440 wxWindow *arg1 = (wxWindow *) 0 ;
30441 wxPoint *arg2 = 0 ;
30442 int arg3 = (int) wxSIZE_USE_EXISTING ;
30443 void *argp1 = 0 ;
30444 int res1 = 0 ;
30445 wxPoint temp2 ;
30446 int val3 ;
30447 int ecode3 = 0 ;
30448 PyObject * obj0 = 0 ;
30449 PyObject * obj1 = 0 ;
30450 PyObject * obj2 = 0 ;
30451 char * kwnames[] = {
30452 (char *) "self",(char *) "pt",(char *) "flags", NULL
30453 };
30454
30455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30457 if (!SWIG_IsOK(res1)) {
30458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30459 }
30460 arg1 = reinterpret_cast< wxWindow * >(argp1);
30461 {
30462 arg2 = &temp2;
30463 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30464 }
30465 if (obj2) {
30466 ecode3 = SWIG_AsVal_int(obj2, &val3);
30467 if (!SWIG_IsOK(ecode3)) {
30468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30469 }
30470 arg3 = static_cast< int >(val3);
30471 }
30472 {
30473 PyThreadState* __tstate = wxPyBeginAllowThreads();
30474 (arg1)->Move((wxPoint const &)*arg2,arg3);
30475 wxPyEndAllowThreads(__tstate);
30476 if (PyErr_Occurred()) SWIG_fail;
30477 }
30478 resultobj = SWIG_Py_Void();
30479 return resultobj;
30480 fail:
30481 return NULL;
30482 }
30483
30484
30485 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30486 PyObject *resultobj = 0;
30487 wxWindow *arg1 = (wxWindow *) 0 ;
30488 int arg2 ;
30489 int arg3 ;
30490 int arg4 = (int) wxSIZE_USE_EXISTING ;
30491 void *argp1 = 0 ;
30492 int res1 = 0 ;
30493 int val2 ;
30494 int ecode2 = 0 ;
30495 int val3 ;
30496 int ecode3 = 0 ;
30497 int val4 ;
30498 int ecode4 = 0 ;
30499 PyObject * obj0 = 0 ;
30500 PyObject * obj1 = 0 ;
30501 PyObject * obj2 = 0 ;
30502 PyObject * obj3 = 0 ;
30503 char * kwnames[] = {
30504 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30505 };
30506
30507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30509 if (!SWIG_IsOK(res1)) {
30510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30511 }
30512 arg1 = reinterpret_cast< wxWindow * >(argp1);
30513 ecode2 = SWIG_AsVal_int(obj1, &val2);
30514 if (!SWIG_IsOK(ecode2)) {
30515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30516 }
30517 arg2 = static_cast< int >(val2);
30518 ecode3 = SWIG_AsVal_int(obj2, &val3);
30519 if (!SWIG_IsOK(ecode3)) {
30520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30521 }
30522 arg3 = static_cast< int >(val3);
30523 if (obj3) {
30524 ecode4 = SWIG_AsVal_int(obj3, &val4);
30525 if (!SWIG_IsOK(ecode4)) {
30526 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30527 }
30528 arg4 = static_cast< int >(val4);
30529 }
30530 {
30531 PyThreadState* __tstate = wxPyBeginAllowThreads();
30532 (arg1)->Move(arg2,arg3,arg4);
30533 wxPyEndAllowThreads(__tstate);
30534 if (PyErr_Occurred()) SWIG_fail;
30535 }
30536 resultobj = SWIG_Py_Void();
30537 return resultobj;
30538 fail:
30539 return NULL;
30540 }
30541
30542
30543 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30544 PyObject *resultobj = 0;
30545 wxWindow *arg1 = (wxWindow *) 0 ;
30546 wxSize const &arg2_defvalue = wxDefaultSize ;
30547 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30548 void *argp1 = 0 ;
30549 int res1 = 0 ;
30550 wxSize temp2 ;
30551 PyObject * obj0 = 0 ;
30552 PyObject * obj1 = 0 ;
30553 char * kwnames[] = {
30554 (char *) "self",(char *) "size", NULL
30555 };
30556
30557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30559 if (!SWIG_IsOK(res1)) {
30560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30561 }
30562 arg1 = reinterpret_cast< wxWindow * >(argp1);
30563 if (obj1) {
30564 {
30565 arg2 = &temp2;
30566 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30567 }
30568 }
30569 {
30570 PyThreadState* __tstate = wxPyBeginAllowThreads();
30571 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30572 wxPyEndAllowThreads(__tstate);
30573 if (PyErr_Occurred()) SWIG_fail;
30574 }
30575 resultobj = SWIG_Py_Void();
30576 return resultobj;
30577 fail:
30578 return NULL;
30579 }
30580
30581
30582 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30583 PyObject *resultobj = 0;
30584 wxWindow *arg1 = (wxWindow *) 0 ;
30585 void *argp1 = 0 ;
30586 int res1 = 0 ;
30587 PyObject *swig_obj[1] ;
30588
30589 if (!args) SWIG_fail;
30590 swig_obj[0] = args;
30591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30592 if (!SWIG_IsOK(res1)) {
30593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30594 }
30595 arg1 = reinterpret_cast< wxWindow * >(argp1);
30596 {
30597 PyThreadState* __tstate = wxPyBeginAllowThreads();
30598 (arg1)->Raise();
30599 wxPyEndAllowThreads(__tstate);
30600 if (PyErr_Occurred()) SWIG_fail;
30601 }
30602 resultobj = SWIG_Py_Void();
30603 return resultobj;
30604 fail:
30605 return NULL;
30606 }
30607
30608
30609 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30610 PyObject *resultobj = 0;
30611 wxWindow *arg1 = (wxWindow *) 0 ;
30612 void *argp1 = 0 ;
30613 int res1 = 0 ;
30614 PyObject *swig_obj[1] ;
30615
30616 if (!args) SWIG_fail;
30617 swig_obj[0] = args;
30618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30619 if (!SWIG_IsOK(res1)) {
30620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30621 }
30622 arg1 = reinterpret_cast< wxWindow * >(argp1);
30623 {
30624 PyThreadState* __tstate = wxPyBeginAllowThreads();
30625 (arg1)->Lower();
30626 wxPyEndAllowThreads(__tstate);
30627 if (PyErr_Occurred()) SWIG_fail;
30628 }
30629 resultobj = SWIG_Py_Void();
30630 return resultobj;
30631 fail:
30632 return NULL;
30633 }
30634
30635
30636 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30637 PyObject *resultobj = 0;
30638 wxWindow *arg1 = (wxWindow *) 0 ;
30639 wxSize *arg2 = 0 ;
30640 void *argp1 = 0 ;
30641 int res1 = 0 ;
30642 wxSize temp2 ;
30643 PyObject * obj0 = 0 ;
30644 PyObject * obj1 = 0 ;
30645 char * kwnames[] = {
30646 (char *) "self",(char *) "size", NULL
30647 };
30648
30649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30651 if (!SWIG_IsOK(res1)) {
30652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30653 }
30654 arg1 = reinterpret_cast< wxWindow * >(argp1);
30655 {
30656 arg2 = &temp2;
30657 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30658 }
30659 {
30660 PyThreadState* __tstate = wxPyBeginAllowThreads();
30661 (arg1)->SetClientSize((wxSize const &)*arg2);
30662 wxPyEndAllowThreads(__tstate);
30663 if (PyErr_Occurred()) SWIG_fail;
30664 }
30665 resultobj = SWIG_Py_Void();
30666 return resultobj;
30667 fail:
30668 return NULL;
30669 }
30670
30671
30672 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30673 PyObject *resultobj = 0;
30674 wxWindow *arg1 = (wxWindow *) 0 ;
30675 int arg2 ;
30676 int arg3 ;
30677 void *argp1 = 0 ;
30678 int res1 = 0 ;
30679 int val2 ;
30680 int ecode2 = 0 ;
30681 int val3 ;
30682 int ecode3 = 0 ;
30683 PyObject * obj0 = 0 ;
30684 PyObject * obj1 = 0 ;
30685 PyObject * obj2 = 0 ;
30686 char * kwnames[] = {
30687 (char *) "self",(char *) "width",(char *) "height", NULL
30688 };
30689
30690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30692 if (!SWIG_IsOK(res1)) {
30693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30694 }
30695 arg1 = reinterpret_cast< wxWindow * >(argp1);
30696 ecode2 = SWIG_AsVal_int(obj1, &val2);
30697 if (!SWIG_IsOK(ecode2)) {
30698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30699 }
30700 arg2 = static_cast< int >(val2);
30701 ecode3 = SWIG_AsVal_int(obj2, &val3);
30702 if (!SWIG_IsOK(ecode3)) {
30703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30704 }
30705 arg3 = static_cast< int >(val3);
30706 {
30707 PyThreadState* __tstate = wxPyBeginAllowThreads();
30708 (arg1)->SetClientSize(arg2,arg3);
30709 wxPyEndAllowThreads(__tstate);
30710 if (PyErr_Occurred()) SWIG_fail;
30711 }
30712 resultobj = SWIG_Py_Void();
30713 return resultobj;
30714 fail:
30715 return NULL;
30716 }
30717
30718
30719 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30720 PyObject *resultobj = 0;
30721 wxWindow *arg1 = (wxWindow *) 0 ;
30722 wxRect *arg2 = 0 ;
30723 void *argp1 = 0 ;
30724 int res1 = 0 ;
30725 wxRect temp2 ;
30726 PyObject * obj0 = 0 ;
30727 PyObject * obj1 = 0 ;
30728 char * kwnames[] = {
30729 (char *) "self",(char *) "rect", NULL
30730 };
30731
30732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30734 if (!SWIG_IsOK(res1)) {
30735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30736 }
30737 arg1 = reinterpret_cast< wxWindow * >(argp1);
30738 {
30739 arg2 = &temp2;
30740 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30741 }
30742 {
30743 PyThreadState* __tstate = wxPyBeginAllowThreads();
30744 (arg1)->SetClientSize((wxRect const &)*arg2);
30745 wxPyEndAllowThreads(__tstate);
30746 if (PyErr_Occurred()) SWIG_fail;
30747 }
30748 resultobj = SWIG_Py_Void();
30749 return resultobj;
30750 fail:
30751 return NULL;
30752 }
30753
30754
30755 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30756 PyObject *resultobj = 0;
30757 wxWindow *arg1 = (wxWindow *) 0 ;
30758 wxPoint result;
30759 void *argp1 = 0 ;
30760 int res1 = 0 ;
30761 PyObject *swig_obj[1] ;
30762
30763 if (!args) SWIG_fail;
30764 swig_obj[0] = args;
30765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30766 if (!SWIG_IsOK(res1)) {
30767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30768 }
30769 arg1 = reinterpret_cast< wxWindow * >(argp1);
30770 {
30771 PyThreadState* __tstate = wxPyBeginAllowThreads();
30772 result = ((wxWindow const *)arg1)->GetPosition();
30773 wxPyEndAllowThreads(__tstate);
30774 if (PyErr_Occurred()) SWIG_fail;
30775 }
30776 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30777 return resultobj;
30778 fail:
30779 return NULL;
30780 }
30781
30782
30783 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30784 PyObject *resultobj = 0;
30785 wxWindow *arg1 = (wxWindow *) 0 ;
30786 int *arg2 = (int *) 0 ;
30787 int *arg3 = (int *) 0 ;
30788 void *argp1 = 0 ;
30789 int res1 = 0 ;
30790 int temp2 ;
30791 int res2 = SWIG_TMPOBJ ;
30792 int temp3 ;
30793 int res3 = SWIG_TMPOBJ ;
30794 PyObject *swig_obj[1] ;
30795
30796 arg2 = &temp2;
30797 arg3 = &temp3;
30798 if (!args) SWIG_fail;
30799 swig_obj[0] = args;
30800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30801 if (!SWIG_IsOK(res1)) {
30802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30803 }
30804 arg1 = reinterpret_cast< wxWindow * >(argp1);
30805 {
30806 PyThreadState* __tstate = wxPyBeginAllowThreads();
30807 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30808 wxPyEndAllowThreads(__tstate);
30809 if (PyErr_Occurred()) SWIG_fail;
30810 }
30811 resultobj = SWIG_Py_Void();
30812 if (SWIG_IsTmpObj(res2)) {
30813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30814 } else {
30815 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30817 }
30818 if (SWIG_IsTmpObj(res3)) {
30819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30820 } else {
30821 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30823 }
30824 return resultobj;
30825 fail:
30826 return NULL;
30827 }
30828
30829
30830 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30831 PyObject *resultobj = 0;
30832 wxWindow *arg1 = (wxWindow *) 0 ;
30833 wxPoint result;
30834 void *argp1 = 0 ;
30835 int res1 = 0 ;
30836 PyObject *swig_obj[1] ;
30837
30838 if (!args) SWIG_fail;
30839 swig_obj[0] = args;
30840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30841 if (!SWIG_IsOK(res1)) {
30842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30843 }
30844 arg1 = reinterpret_cast< wxWindow * >(argp1);
30845 {
30846 PyThreadState* __tstate = wxPyBeginAllowThreads();
30847 result = ((wxWindow const *)arg1)->GetScreenPosition();
30848 wxPyEndAllowThreads(__tstate);
30849 if (PyErr_Occurred()) SWIG_fail;
30850 }
30851 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30852 return resultobj;
30853 fail:
30854 return NULL;
30855 }
30856
30857
30858 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30859 PyObject *resultobj = 0;
30860 wxWindow *arg1 = (wxWindow *) 0 ;
30861 int *arg2 = (int *) 0 ;
30862 int *arg3 = (int *) 0 ;
30863 void *argp1 = 0 ;
30864 int res1 = 0 ;
30865 int temp2 ;
30866 int res2 = SWIG_TMPOBJ ;
30867 int temp3 ;
30868 int res3 = SWIG_TMPOBJ ;
30869 PyObject *swig_obj[1] ;
30870
30871 arg2 = &temp2;
30872 arg3 = &temp3;
30873 if (!args) SWIG_fail;
30874 swig_obj[0] = args;
30875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30876 if (!SWIG_IsOK(res1)) {
30877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30878 }
30879 arg1 = reinterpret_cast< wxWindow * >(argp1);
30880 {
30881 PyThreadState* __tstate = wxPyBeginAllowThreads();
30882 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30883 wxPyEndAllowThreads(__tstate);
30884 if (PyErr_Occurred()) SWIG_fail;
30885 }
30886 resultobj = SWIG_Py_Void();
30887 if (SWIG_IsTmpObj(res2)) {
30888 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30889 } else {
30890 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30891 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30892 }
30893 if (SWIG_IsTmpObj(res3)) {
30894 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30895 } else {
30896 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30897 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30898 }
30899 return resultobj;
30900 fail:
30901 return NULL;
30902 }
30903
30904
30905 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30906 PyObject *resultobj = 0;
30907 wxWindow *arg1 = (wxWindow *) 0 ;
30908 wxRect result;
30909 void *argp1 = 0 ;
30910 int res1 = 0 ;
30911 PyObject *swig_obj[1] ;
30912
30913 if (!args) SWIG_fail;
30914 swig_obj[0] = args;
30915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30916 if (!SWIG_IsOK(res1)) {
30917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30918 }
30919 arg1 = reinterpret_cast< wxWindow * >(argp1);
30920 {
30921 PyThreadState* __tstate = wxPyBeginAllowThreads();
30922 result = ((wxWindow const *)arg1)->GetScreenRect();
30923 wxPyEndAllowThreads(__tstate);
30924 if (PyErr_Occurred()) SWIG_fail;
30925 }
30926 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30927 return resultobj;
30928 fail:
30929 return NULL;
30930 }
30931
30932
30933 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30934 PyObject *resultobj = 0;
30935 wxWindow *arg1 = (wxWindow *) 0 ;
30936 wxSize result;
30937 void *argp1 = 0 ;
30938 int res1 = 0 ;
30939 PyObject *swig_obj[1] ;
30940
30941 if (!args) SWIG_fail;
30942 swig_obj[0] = args;
30943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30944 if (!SWIG_IsOK(res1)) {
30945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30946 }
30947 arg1 = reinterpret_cast< wxWindow * >(argp1);
30948 {
30949 PyThreadState* __tstate = wxPyBeginAllowThreads();
30950 result = ((wxWindow const *)arg1)->GetSize();
30951 wxPyEndAllowThreads(__tstate);
30952 if (PyErr_Occurred()) SWIG_fail;
30953 }
30954 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30955 return resultobj;
30956 fail:
30957 return NULL;
30958 }
30959
30960
30961 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30962 PyObject *resultobj = 0;
30963 wxWindow *arg1 = (wxWindow *) 0 ;
30964 int *arg2 = (int *) 0 ;
30965 int *arg3 = (int *) 0 ;
30966 void *argp1 = 0 ;
30967 int res1 = 0 ;
30968 int temp2 ;
30969 int res2 = SWIG_TMPOBJ ;
30970 int temp3 ;
30971 int res3 = SWIG_TMPOBJ ;
30972 PyObject *swig_obj[1] ;
30973
30974 arg2 = &temp2;
30975 arg3 = &temp3;
30976 if (!args) SWIG_fail;
30977 swig_obj[0] = args;
30978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30979 if (!SWIG_IsOK(res1)) {
30980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30981 }
30982 arg1 = reinterpret_cast< wxWindow * >(argp1);
30983 {
30984 PyThreadState* __tstate = wxPyBeginAllowThreads();
30985 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30986 wxPyEndAllowThreads(__tstate);
30987 if (PyErr_Occurred()) SWIG_fail;
30988 }
30989 resultobj = SWIG_Py_Void();
30990 if (SWIG_IsTmpObj(res2)) {
30991 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30992 } else {
30993 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30994 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30995 }
30996 if (SWIG_IsTmpObj(res3)) {
30997 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30998 } else {
30999 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31000 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31001 }
31002 return resultobj;
31003 fail:
31004 return NULL;
31005 }
31006
31007
31008 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31009 PyObject *resultobj = 0;
31010 wxWindow *arg1 = (wxWindow *) 0 ;
31011 wxRect result;
31012 void *argp1 = 0 ;
31013 int res1 = 0 ;
31014 PyObject *swig_obj[1] ;
31015
31016 if (!args) SWIG_fail;
31017 swig_obj[0] = args;
31018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31019 if (!SWIG_IsOK(res1)) {
31020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31021 }
31022 arg1 = reinterpret_cast< wxWindow * >(argp1);
31023 {
31024 PyThreadState* __tstate = wxPyBeginAllowThreads();
31025 result = ((wxWindow const *)arg1)->GetRect();
31026 wxPyEndAllowThreads(__tstate);
31027 if (PyErr_Occurred()) SWIG_fail;
31028 }
31029 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31030 return resultobj;
31031 fail:
31032 return NULL;
31033 }
31034
31035
31036 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31037 PyObject *resultobj = 0;
31038 wxWindow *arg1 = (wxWindow *) 0 ;
31039 wxSize result;
31040 void *argp1 = 0 ;
31041 int res1 = 0 ;
31042 PyObject *swig_obj[1] ;
31043
31044 if (!args) SWIG_fail;
31045 swig_obj[0] = args;
31046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31047 if (!SWIG_IsOK(res1)) {
31048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31049 }
31050 arg1 = reinterpret_cast< wxWindow * >(argp1);
31051 {
31052 PyThreadState* __tstate = wxPyBeginAllowThreads();
31053 result = ((wxWindow const *)arg1)->GetClientSize();
31054 wxPyEndAllowThreads(__tstate);
31055 if (PyErr_Occurred()) SWIG_fail;
31056 }
31057 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31058 return resultobj;
31059 fail:
31060 return NULL;
31061 }
31062
31063
31064 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31065 PyObject *resultobj = 0;
31066 wxWindow *arg1 = (wxWindow *) 0 ;
31067 int *arg2 = (int *) 0 ;
31068 int *arg3 = (int *) 0 ;
31069 void *argp1 = 0 ;
31070 int res1 = 0 ;
31071 int temp2 ;
31072 int res2 = SWIG_TMPOBJ ;
31073 int temp3 ;
31074 int res3 = SWIG_TMPOBJ ;
31075 PyObject *swig_obj[1] ;
31076
31077 arg2 = &temp2;
31078 arg3 = &temp3;
31079 if (!args) SWIG_fail;
31080 swig_obj[0] = args;
31081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31082 if (!SWIG_IsOK(res1)) {
31083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31084 }
31085 arg1 = reinterpret_cast< wxWindow * >(argp1);
31086 {
31087 PyThreadState* __tstate = wxPyBeginAllowThreads();
31088 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31089 wxPyEndAllowThreads(__tstate);
31090 if (PyErr_Occurred()) SWIG_fail;
31091 }
31092 resultobj = SWIG_Py_Void();
31093 if (SWIG_IsTmpObj(res2)) {
31094 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31095 } else {
31096 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31097 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31098 }
31099 if (SWIG_IsTmpObj(res3)) {
31100 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31101 } else {
31102 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31103 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31104 }
31105 return resultobj;
31106 fail:
31107 return NULL;
31108 }
31109
31110
31111 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31112 PyObject *resultobj = 0;
31113 wxWindow *arg1 = (wxWindow *) 0 ;
31114 wxPoint result;
31115 void *argp1 = 0 ;
31116 int res1 = 0 ;
31117 PyObject *swig_obj[1] ;
31118
31119 if (!args) SWIG_fail;
31120 swig_obj[0] = args;
31121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31122 if (!SWIG_IsOK(res1)) {
31123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31124 }
31125 arg1 = reinterpret_cast< wxWindow * >(argp1);
31126 {
31127 PyThreadState* __tstate = wxPyBeginAllowThreads();
31128 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31129 wxPyEndAllowThreads(__tstate);
31130 if (PyErr_Occurred()) SWIG_fail;
31131 }
31132 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31133 return resultobj;
31134 fail:
31135 return NULL;
31136 }
31137
31138
31139 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31140 PyObject *resultobj = 0;
31141 wxWindow *arg1 = (wxWindow *) 0 ;
31142 wxRect result;
31143 void *argp1 = 0 ;
31144 int res1 = 0 ;
31145 PyObject *swig_obj[1] ;
31146
31147 if (!args) SWIG_fail;
31148 swig_obj[0] = args;
31149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31150 if (!SWIG_IsOK(res1)) {
31151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31152 }
31153 arg1 = reinterpret_cast< wxWindow * >(argp1);
31154 {
31155 PyThreadState* __tstate = wxPyBeginAllowThreads();
31156 result = ((wxWindow const *)arg1)->GetClientRect();
31157 wxPyEndAllowThreads(__tstate);
31158 if (PyErr_Occurred()) SWIG_fail;
31159 }
31160 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31161 return resultobj;
31162 fail:
31163 return NULL;
31164 }
31165
31166
31167 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31168 PyObject *resultobj = 0;
31169 wxWindow *arg1 = (wxWindow *) 0 ;
31170 wxSize result;
31171 void *argp1 = 0 ;
31172 int res1 = 0 ;
31173 PyObject *swig_obj[1] ;
31174
31175 if (!args) SWIG_fail;
31176 swig_obj[0] = args;
31177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31178 if (!SWIG_IsOK(res1)) {
31179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31180 }
31181 arg1 = reinterpret_cast< wxWindow * >(argp1);
31182 {
31183 PyThreadState* __tstate = wxPyBeginAllowThreads();
31184 result = ((wxWindow const *)arg1)->GetBestSize();
31185 wxPyEndAllowThreads(__tstate);
31186 if (PyErr_Occurred()) SWIG_fail;
31187 }
31188 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31189 return resultobj;
31190 fail:
31191 return NULL;
31192 }
31193
31194
31195 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31196 PyObject *resultobj = 0;
31197 wxWindow *arg1 = (wxWindow *) 0 ;
31198 int *arg2 = (int *) 0 ;
31199 int *arg3 = (int *) 0 ;
31200 void *argp1 = 0 ;
31201 int res1 = 0 ;
31202 int temp2 ;
31203 int res2 = SWIG_TMPOBJ ;
31204 int temp3 ;
31205 int res3 = SWIG_TMPOBJ ;
31206 PyObject *swig_obj[1] ;
31207
31208 arg2 = &temp2;
31209 arg3 = &temp3;
31210 if (!args) SWIG_fail;
31211 swig_obj[0] = args;
31212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31213 if (!SWIG_IsOK(res1)) {
31214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31215 }
31216 arg1 = reinterpret_cast< wxWindow * >(argp1);
31217 {
31218 PyThreadState* __tstate = wxPyBeginAllowThreads();
31219 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31220 wxPyEndAllowThreads(__tstate);
31221 if (PyErr_Occurred()) SWIG_fail;
31222 }
31223 resultobj = SWIG_Py_Void();
31224 if (SWIG_IsTmpObj(res2)) {
31225 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31226 } else {
31227 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31229 }
31230 if (SWIG_IsTmpObj(res3)) {
31231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31232 } else {
31233 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31235 }
31236 return resultobj;
31237 fail:
31238 return NULL;
31239 }
31240
31241
31242 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31243 PyObject *resultobj = 0;
31244 wxWindow *arg1 = (wxWindow *) 0 ;
31245 void *argp1 = 0 ;
31246 int res1 = 0 ;
31247 PyObject *swig_obj[1] ;
31248
31249 if (!args) SWIG_fail;
31250 swig_obj[0] = args;
31251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31252 if (!SWIG_IsOK(res1)) {
31253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31254 }
31255 arg1 = reinterpret_cast< wxWindow * >(argp1);
31256 {
31257 PyThreadState* __tstate = wxPyBeginAllowThreads();
31258 (arg1)->InvalidateBestSize();
31259 wxPyEndAllowThreads(__tstate);
31260 if (PyErr_Occurred()) SWIG_fail;
31261 }
31262 resultobj = SWIG_Py_Void();
31263 return resultobj;
31264 fail:
31265 return NULL;
31266 }
31267
31268
31269 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31270 PyObject *resultobj = 0;
31271 wxWindow *arg1 = (wxWindow *) 0 ;
31272 wxSize *arg2 = 0 ;
31273 void *argp1 = 0 ;
31274 int res1 = 0 ;
31275 wxSize temp2 ;
31276 PyObject * obj0 = 0 ;
31277 PyObject * obj1 = 0 ;
31278 char * kwnames[] = {
31279 (char *) "self",(char *) "size", NULL
31280 };
31281
31282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31284 if (!SWIG_IsOK(res1)) {
31285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31286 }
31287 arg1 = reinterpret_cast< wxWindow * >(argp1);
31288 {
31289 arg2 = &temp2;
31290 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31291 }
31292 {
31293 PyThreadState* __tstate = wxPyBeginAllowThreads();
31294 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31295 wxPyEndAllowThreads(__tstate);
31296 if (PyErr_Occurred()) SWIG_fail;
31297 }
31298 resultobj = SWIG_Py_Void();
31299 return resultobj;
31300 fail:
31301 return NULL;
31302 }
31303
31304
31305 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31306 PyObject *resultobj = 0;
31307 wxWindow *arg1 = (wxWindow *) 0 ;
31308 wxSize result;
31309 void *argp1 = 0 ;
31310 int res1 = 0 ;
31311 PyObject *swig_obj[1] ;
31312
31313 if (!args) SWIG_fail;
31314 swig_obj[0] = args;
31315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31316 if (!SWIG_IsOK(res1)) {
31317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31318 }
31319 arg1 = reinterpret_cast< wxWindow * >(argp1);
31320 {
31321 PyThreadState* __tstate = wxPyBeginAllowThreads();
31322 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31323 wxPyEndAllowThreads(__tstate);
31324 if (PyErr_Occurred()) SWIG_fail;
31325 }
31326 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31327 return resultobj;
31328 fail:
31329 return NULL;
31330 }
31331
31332
31333 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31334 PyObject *resultobj = 0;
31335 wxWindow *arg1 = (wxWindow *) 0 ;
31336 wxSize result;
31337 void *argp1 = 0 ;
31338 int res1 = 0 ;
31339 PyObject *swig_obj[1] ;
31340
31341 if (!args) SWIG_fail;
31342 swig_obj[0] = args;
31343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31344 if (!SWIG_IsOK(res1)) {
31345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31346 }
31347 arg1 = reinterpret_cast< wxWindow * >(argp1);
31348 {
31349 PyThreadState* __tstate = wxPyBeginAllowThreads();
31350 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31351 wxPyEndAllowThreads(__tstate);
31352 if (PyErr_Occurred()) SWIG_fail;
31353 }
31354 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31355 return resultobj;
31356 fail:
31357 return NULL;
31358 }
31359
31360
31361 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31362 PyObject *resultobj = 0;
31363 wxWindow *arg1 = (wxWindow *) 0 ;
31364 int arg2 = (int) wxBOTH ;
31365 void *argp1 = 0 ;
31366 int res1 = 0 ;
31367 int val2 ;
31368 int ecode2 = 0 ;
31369 PyObject * obj0 = 0 ;
31370 PyObject * obj1 = 0 ;
31371 char * kwnames[] = {
31372 (char *) "self",(char *) "direction", NULL
31373 };
31374
31375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31377 if (!SWIG_IsOK(res1)) {
31378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31379 }
31380 arg1 = reinterpret_cast< wxWindow * >(argp1);
31381 if (obj1) {
31382 ecode2 = SWIG_AsVal_int(obj1, &val2);
31383 if (!SWIG_IsOK(ecode2)) {
31384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31385 }
31386 arg2 = static_cast< int >(val2);
31387 }
31388 {
31389 PyThreadState* __tstate = wxPyBeginAllowThreads();
31390 (arg1)->Center(arg2);
31391 wxPyEndAllowThreads(__tstate);
31392 if (PyErr_Occurred()) SWIG_fail;
31393 }
31394 resultobj = SWIG_Py_Void();
31395 return resultobj;
31396 fail:
31397 return NULL;
31398 }
31399
31400
31401 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31402 PyObject *resultobj = 0;
31403 wxWindow *arg1 = (wxWindow *) 0 ;
31404 int arg2 = (int) wxBOTH ;
31405 void *argp1 = 0 ;
31406 int res1 = 0 ;
31407 int val2 ;
31408 int ecode2 = 0 ;
31409 PyObject * obj0 = 0 ;
31410 PyObject * obj1 = 0 ;
31411 char * kwnames[] = {
31412 (char *) "self",(char *) "dir", NULL
31413 };
31414
31415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31417 if (!SWIG_IsOK(res1)) {
31418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31419 }
31420 arg1 = reinterpret_cast< wxWindow * >(argp1);
31421 if (obj1) {
31422 ecode2 = SWIG_AsVal_int(obj1, &val2);
31423 if (!SWIG_IsOK(ecode2)) {
31424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31425 }
31426 arg2 = static_cast< int >(val2);
31427 }
31428 {
31429 PyThreadState* __tstate = wxPyBeginAllowThreads();
31430 (arg1)->CenterOnParent(arg2);
31431 wxPyEndAllowThreads(__tstate);
31432 if (PyErr_Occurred()) SWIG_fail;
31433 }
31434 resultobj = SWIG_Py_Void();
31435 return resultobj;
31436 fail:
31437 return NULL;
31438 }
31439
31440
31441 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31442 PyObject *resultobj = 0;
31443 wxWindow *arg1 = (wxWindow *) 0 ;
31444 void *argp1 = 0 ;
31445 int res1 = 0 ;
31446 PyObject *swig_obj[1] ;
31447
31448 if (!args) SWIG_fail;
31449 swig_obj[0] = args;
31450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31451 if (!SWIG_IsOK(res1)) {
31452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31453 }
31454 arg1 = reinterpret_cast< wxWindow * >(argp1);
31455 {
31456 PyThreadState* __tstate = wxPyBeginAllowThreads();
31457 (arg1)->Fit();
31458 wxPyEndAllowThreads(__tstate);
31459 if (PyErr_Occurred()) SWIG_fail;
31460 }
31461 resultobj = SWIG_Py_Void();
31462 return resultobj;
31463 fail:
31464 return NULL;
31465 }
31466
31467
31468 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31469 PyObject *resultobj = 0;
31470 wxWindow *arg1 = (wxWindow *) 0 ;
31471 void *argp1 = 0 ;
31472 int res1 = 0 ;
31473 PyObject *swig_obj[1] ;
31474
31475 if (!args) SWIG_fail;
31476 swig_obj[0] = args;
31477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31478 if (!SWIG_IsOK(res1)) {
31479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31480 }
31481 arg1 = reinterpret_cast< wxWindow * >(argp1);
31482 {
31483 PyThreadState* __tstate = wxPyBeginAllowThreads();
31484 (arg1)->FitInside();
31485 wxPyEndAllowThreads(__tstate);
31486 if (PyErr_Occurred()) SWIG_fail;
31487 }
31488 resultobj = SWIG_Py_Void();
31489 return resultobj;
31490 fail:
31491 return NULL;
31492 }
31493
31494
31495 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31496 PyObject *resultobj = 0;
31497 wxWindow *arg1 = (wxWindow *) 0 ;
31498 int arg2 ;
31499 int arg3 ;
31500 int arg4 = (int) -1 ;
31501 int arg5 = (int) -1 ;
31502 int arg6 = (int) -1 ;
31503 int arg7 = (int) -1 ;
31504 void *argp1 = 0 ;
31505 int res1 = 0 ;
31506 int val2 ;
31507 int ecode2 = 0 ;
31508 int val3 ;
31509 int ecode3 = 0 ;
31510 int val4 ;
31511 int ecode4 = 0 ;
31512 int val5 ;
31513 int ecode5 = 0 ;
31514 int val6 ;
31515 int ecode6 = 0 ;
31516 int val7 ;
31517 int ecode7 = 0 ;
31518 PyObject * obj0 = 0 ;
31519 PyObject * obj1 = 0 ;
31520 PyObject * obj2 = 0 ;
31521 PyObject * obj3 = 0 ;
31522 PyObject * obj4 = 0 ;
31523 PyObject * obj5 = 0 ;
31524 PyObject * obj6 = 0 ;
31525 char * kwnames[] = {
31526 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31527 };
31528
31529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31531 if (!SWIG_IsOK(res1)) {
31532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31533 }
31534 arg1 = reinterpret_cast< wxWindow * >(argp1);
31535 ecode2 = SWIG_AsVal_int(obj1, &val2);
31536 if (!SWIG_IsOK(ecode2)) {
31537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31538 }
31539 arg2 = static_cast< int >(val2);
31540 ecode3 = SWIG_AsVal_int(obj2, &val3);
31541 if (!SWIG_IsOK(ecode3)) {
31542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31543 }
31544 arg3 = static_cast< int >(val3);
31545 if (obj3) {
31546 ecode4 = SWIG_AsVal_int(obj3, &val4);
31547 if (!SWIG_IsOK(ecode4)) {
31548 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31549 }
31550 arg4 = static_cast< int >(val4);
31551 }
31552 if (obj4) {
31553 ecode5 = SWIG_AsVal_int(obj4, &val5);
31554 if (!SWIG_IsOK(ecode5)) {
31555 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31556 }
31557 arg5 = static_cast< int >(val5);
31558 }
31559 if (obj5) {
31560 ecode6 = SWIG_AsVal_int(obj5, &val6);
31561 if (!SWIG_IsOK(ecode6)) {
31562 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31563 }
31564 arg6 = static_cast< int >(val6);
31565 }
31566 if (obj6) {
31567 ecode7 = SWIG_AsVal_int(obj6, &val7);
31568 if (!SWIG_IsOK(ecode7)) {
31569 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31570 }
31571 arg7 = static_cast< int >(val7);
31572 }
31573 {
31574 PyThreadState* __tstate = wxPyBeginAllowThreads();
31575 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31576 wxPyEndAllowThreads(__tstate);
31577 if (PyErr_Occurred()) SWIG_fail;
31578 }
31579 resultobj = SWIG_Py_Void();
31580 return resultobj;
31581 fail:
31582 return NULL;
31583 }
31584
31585
31586 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31587 PyObject *resultobj = 0;
31588 wxWindow *arg1 = (wxWindow *) 0 ;
31589 wxSize *arg2 = 0 ;
31590 wxSize const &arg3_defvalue = wxDefaultSize ;
31591 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31592 wxSize const &arg4_defvalue = wxDefaultSize ;
31593 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31594 void *argp1 = 0 ;
31595 int res1 = 0 ;
31596 wxSize temp2 ;
31597 wxSize temp3 ;
31598 wxSize temp4 ;
31599 PyObject * obj0 = 0 ;
31600 PyObject * obj1 = 0 ;
31601 PyObject * obj2 = 0 ;
31602 PyObject * obj3 = 0 ;
31603 char * kwnames[] = {
31604 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31605 };
31606
31607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31609 if (!SWIG_IsOK(res1)) {
31610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31611 }
31612 arg1 = reinterpret_cast< wxWindow * >(argp1);
31613 {
31614 arg2 = &temp2;
31615 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31616 }
31617 if (obj2) {
31618 {
31619 arg3 = &temp3;
31620 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31621 }
31622 }
31623 if (obj3) {
31624 {
31625 arg4 = &temp4;
31626 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31627 }
31628 }
31629 {
31630 PyThreadState* __tstate = wxPyBeginAllowThreads();
31631 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31632 wxPyEndAllowThreads(__tstate);
31633 if (PyErr_Occurred()) SWIG_fail;
31634 }
31635 resultobj = SWIG_Py_Void();
31636 return resultobj;
31637 fail:
31638 return NULL;
31639 }
31640
31641
31642 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31643 PyObject *resultobj = 0;
31644 wxWindow *arg1 = (wxWindow *) 0 ;
31645 int arg2 ;
31646 int arg3 ;
31647 int arg4 = (int) -1 ;
31648 int arg5 = (int) -1 ;
31649 void *argp1 = 0 ;
31650 int res1 = 0 ;
31651 int val2 ;
31652 int ecode2 = 0 ;
31653 int val3 ;
31654 int ecode3 = 0 ;
31655 int val4 ;
31656 int ecode4 = 0 ;
31657 int val5 ;
31658 int ecode5 = 0 ;
31659 PyObject * obj0 = 0 ;
31660 PyObject * obj1 = 0 ;
31661 PyObject * obj2 = 0 ;
31662 PyObject * obj3 = 0 ;
31663 PyObject * obj4 = 0 ;
31664 char * kwnames[] = {
31665 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31666 };
31667
31668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31670 if (!SWIG_IsOK(res1)) {
31671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31672 }
31673 arg1 = reinterpret_cast< wxWindow * >(argp1);
31674 ecode2 = SWIG_AsVal_int(obj1, &val2);
31675 if (!SWIG_IsOK(ecode2)) {
31676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31677 }
31678 arg2 = static_cast< int >(val2);
31679 ecode3 = SWIG_AsVal_int(obj2, &val3);
31680 if (!SWIG_IsOK(ecode3)) {
31681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31682 }
31683 arg3 = static_cast< int >(val3);
31684 if (obj3) {
31685 ecode4 = SWIG_AsVal_int(obj3, &val4);
31686 if (!SWIG_IsOK(ecode4)) {
31687 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31688 }
31689 arg4 = static_cast< int >(val4);
31690 }
31691 if (obj4) {
31692 ecode5 = SWIG_AsVal_int(obj4, &val5);
31693 if (!SWIG_IsOK(ecode5)) {
31694 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31695 }
31696 arg5 = static_cast< int >(val5);
31697 }
31698 {
31699 PyThreadState* __tstate = wxPyBeginAllowThreads();
31700 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31701 wxPyEndAllowThreads(__tstate);
31702 if (PyErr_Occurred()) SWIG_fail;
31703 }
31704 resultobj = SWIG_Py_Void();
31705 return resultobj;
31706 fail:
31707 return NULL;
31708 }
31709
31710
31711 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31712 PyObject *resultobj = 0;
31713 wxWindow *arg1 = (wxWindow *) 0 ;
31714 wxSize *arg2 = 0 ;
31715 wxSize const &arg3_defvalue = wxDefaultSize ;
31716 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31717 void *argp1 = 0 ;
31718 int res1 = 0 ;
31719 wxSize temp2 ;
31720 wxSize temp3 ;
31721 PyObject * obj0 = 0 ;
31722 PyObject * obj1 = 0 ;
31723 PyObject * obj2 = 0 ;
31724 char * kwnames[] = {
31725 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31726 };
31727
31728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31730 if (!SWIG_IsOK(res1)) {
31731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31732 }
31733 arg1 = reinterpret_cast< wxWindow * >(argp1);
31734 {
31735 arg2 = &temp2;
31736 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31737 }
31738 if (obj2) {
31739 {
31740 arg3 = &temp3;
31741 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31742 }
31743 }
31744 {
31745 PyThreadState* __tstate = wxPyBeginAllowThreads();
31746 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31747 wxPyEndAllowThreads(__tstate);
31748 if (PyErr_Occurred()) SWIG_fail;
31749 }
31750 resultobj = SWIG_Py_Void();
31751 return resultobj;
31752 fail:
31753 return NULL;
31754 }
31755
31756
31757 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31758 PyObject *resultobj = 0;
31759 wxWindow *arg1 = (wxWindow *) 0 ;
31760 wxSize result;
31761 void *argp1 = 0 ;
31762 int res1 = 0 ;
31763 PyObject *swig_obj[1] ;
31764
31765 if (!args) SWIG_fail;
31766 swig_obj[0] = args;
31767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31768 if (!SWIG_IsOK(res1)) {
31769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31770 }
31771 arg1 = reinterpret_cast< wxWindow * >(argp1);
31772 {
31773 PyThreadState* __tstate = wxPyBeginAllowThreads();
31774 result = ((wxWindow const *)arg1)->GetMaxSize();
31775 wxPyEndAllowThreads(__tstate);
31776 if (PyErr_Occurred()) SWIG_fail;
31777 }
31778 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31779 return resultobj;
31780 fail:
31781 return NULL;
31782 }
31783
31784
31785 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31786 PyObject *resultobj = 0;
31787 wxWindow *arg1 = (wxWindow *) 0 ;
31788 wxSize result;
31789 void *argp1 = 0 ;
31790 int res1 = 0 ;
31791 PyObject *swig_obj[1] ;
31792
31793 if (!args) SWIG_fail;
31794 swig_obj[0] = args;
31795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31796 if (!SWIG_IsOK(res1)) {
31797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31798 }
31799 arg1 = reinterpret_cast< wxWindow * >(argp1);
31800 {
31801 PyThreadState* __tstate = wxPyBeginAllowThreads();
31802 result = ((wxWindow const *)arg1)->GetMinSize();
31803 wxPyEndAllowThreads(__tstate);
31804 if (PyErr_Occurred()) SWIG_fail;
31805 }
31806 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31807 return resultobj;
31808 fail:
31809 return NULL;
31810 }
31811
31812
31813 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31814 PyObject *resultobj = 0;
31815 wxWindow *arg1 = (wxWindow *) 0 ;
31816 wxSize *arg2 = 0 ;
31817 void *argp1 = 0 ;
31818 int res1 = 0 ;
31819 wxSize temp2 ;
31820 PyObject * obj0 = 0 ;
31821 PyObject * obj1 = 0 ;
31822 char * kwnames[] = {
31823 (char *) "self",(char *) "minSize", NULL
31824 };
31825
31826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31828 if (!SWIG_IsOK(res1)) {
31829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31830 }
31831 arg1 = reinterpret_cast< wxWindow * >(argp1);
31832 {
31833 arg2 = &temp2;
31834 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31835 }
31836 {
31837 PyThreadState* __tstate = wxPyBeginAllowThreads();
31838 (arg1)->SetMinSize((wxSize const &)*arg2);
31839 wxPyEndAllowThreads(__tstate);
31840 if (PyErr_Occurred()) SWIG_fail;
31841 }
31842 resultobj = SWIG_Py_Void();
31843 return resultobj;
31844 fail:
31845 return NULL;
31846 }
31847
31848
31849 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31850 PyObject *resultobj = 0;
31851 wxWindow *arg1 = (wxWindow *) 0 ;
31852 wxSize *arg2 = 0 ;
31853 void *argp1 = 0 ;
31854 int res1 = 0 ;
31855 wxSize temp2 ;
31856 PyObject * obj0 = 0 ;
31857 PyObject * obj1 = 0 ;
31858 char * kwnames[] = {
31859 (char *) "self",(char *) "maxSize", NULL
31860 };
31861
31862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31864 if (!SWIG_IsOK(res1)) {
31865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31866 }
31867 arg1 = reinterpret_cast< wxWindow * >(argp1);
31868 {
31869 arg2 = &temp2;
31870 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31871 }
31872 {
31873 PyThreadState* __tstate = wxPyBeginAllowThreads();
31874 (arg1)->SetMaxSize((wxSize const &)*arg2);
31875 wxPyEndAllowThreads(__tstate);
31876 if (PyErr_Occurred()) SWIG_fail;
31877 }
31878 resultobj = SWIG_Py_Void();
31879 return resultobj;
31880 fail:
31881 return NULL;
31882 }
31883
31884
31885 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31886 PyObject *resultobj = 0;
31887 wxWindow *arg1 = (wxWindow *) 0 ;
31888 int result;
31889 void *argp1 = 0 ;
31890 int res1 = 0 ;
31891 PyObject *swig_obj[1] ;
31892
31893 if (!args) SWIG_fail;
31894 swig_obj[0] = args;
31895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31896 if (!SWIG_IsOK(res1)) {
31897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31898 }
31899 arg1 = reinterpret_cast< wxWindow * >(argp1);
31900 {
31901 PyThreadState* __tstate = wxPyBeginAllowThreads();
31902 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31903 wxPyEndAllowThreads(__tstate);
31904 if (PyErr_Occurred()) SWIG_fail;
31905 }
31906 resultobj = SWIG_From_int(static_cast< int >(result));
31907 return resultobj;
31908 fail:
31909 return NULL;
31910 }
31911
31912
31913 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31914 PyObject *resultobj = 0;
31915 wxWindow *arg1 = (wxWindow *) 0 ;
31916 int result;
31917 void *argp1 = 0 ;
31918 int res1 = 0 ;
31919 PyObject *swig_obj[1] ;
31920
31921 if (!args) SWIG_fail;
31922 swig_obj[0] = args;
31923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31924 if (!SWIG_IsOK(res1)) {
31925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31926 }
31927 arg1 = reinterpret_cast< wxWindow * >(argp1);
31928 {
31929 PyThreadState* __tstate = wxPyBeginAllowThreads();
31930 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31931 wxPyEndAllowThreads(__tstate);
31932 if (PyErr_Occurred()) SWIG_fail;
31933 }
31934 resultobj = SWIG_From_int(static_cast< int >(result));
31935 return resultobj;
31936 fail:
31937 return NULL;
31938 }
31939
31940
31941 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31942 PyObject *resultobj = 0;
31943 wxWindow *arg1 = (wxWindow *) 0 ;
31944 int result;
31945 void *argp1 = 0 ;
31946 int res1 = 0 ;
31947 PyObject *swig_obj[1] ;
31948
31949 if (!args) SWIG_fail;
31950 swig_obj[0] = args;
31951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31952 if (!SWIG_IsOK(res1)) {
31953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31954 }
31955 arg1 = reinterpret_cast< wxWindow * >(argp1);
31956 {
31957 PyThreadState* __tstate = wxPyBeginAllowThreads();
31958 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31959 wxPyEndAllowThreads(__tstate);
31960 if (PyErr_Occurred()) SWIG_fail;
31961 }
31962 resultobj = SWIG_From_int(static_cast< int >(result));
31963 return resultobj;
31964 fail:
31965 return NULL;
31966 }
31967
31968
31969 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31970 PyObject *resultobj = 0;
31971 wxWindow *arg1 = (wxWindow *) 0 ;
31972 int result;
31973 void *argp1 = 0 ;
31974 int res1 = 0 ;
31975 PyObject *swig_obj[1] ;
31976
31977 if (!args) SWIG_fail;
31978 swig_obj[0] = args;
31979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31980 if (!SWIG_IsOK(res1)) {
31981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31982 }
31983 arg1 = reinterpret_cast< wxWindow * >(argp1);
31984 {
31985 PyThreadState* __tstate = wxPyBeginAllowThreads();
31986 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31987 wxPyEndAllowThreads(__tstate);
31988 if (PyErr_Occurred()) SWIG_fail;
31989 }
31990 resultobj = SWIG_From_int(static_cast< int >(result));
31991 return resultobj;
31992 fail:
31993 return NULL;
31994 }
31995
31996
31997 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31998 PyObject *resultobj = 0;
31999 wxWindow *arg1 = (wxWindow *) 0 ;
32000 wxSize *arg2 = 0 ;
32001 void *argp1 = 0 ;
32002 int res1 = 0 ;
32003 wxSize temp2 ;
32004 PyObject * obj0 = 0 ;
32005 PyObject * obj1 = 0 ;
32006 char * kwnames[] = {
32007 (char *) "self",(char *) "size", NULL
32008 };
32009
32010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32012 if (!SWIG_IsOK(res1)) {
32013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32014 }
32015 arg1 = reinterpret_cast< wxWindow * >(argp1);
32016 {
32017 arg2 = &temp2;
32018 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32019 }
32020 {
32021 PyThreadState* __tstate = wxPyBeginAllowThreads();
32022 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32023 wxPyEndAllowThreads(__tstate);
32024 if (PyErr_Occurred()) SWIG_fail;
32025 }
32026 resultobj = SWIG_Py_Void();
32027 return resultobj;
32028 fail:
32029 return NULL;
32030 }
32031
32032
32033 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32034 PyObject *resultobj = 0;
32035 wxWindow *arg1 = (wxWindow *) 0 ;
32036 int arg2 ;
32037 int arg3 ;
32038 void *argp1 = 0 ;
32039 int res1 = 0 ;
32040 int val2 ;
32041 int ecode2 = 0 ;
32042 int val3 ;
32043 int ecode3 = 0 ;
32044 PyObject * obj0 = 0 ;
32045 PyObject * obj1 = 0 ;
32046 PyObject * obj2 = 0 ;
32047 char * kwnames[] = {
32048 (char *) "self",(char *) "w",(char *) "h", NULL
32049 };
32050
32051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32053 if (!SWIG_IsOK(res1)) {
32054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32055 }
32056 arg1 = reinterpret_cast< wxWindow * >(argp1);
32057 ecode2 = SWIG_AsVal_int(obj1, &val2);
32058 if (!SWIG_IsOK(ecode2)) {
32059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32060 }
32061 arg2 = static_cast< int >(val2);
32062 ecode3 = SWIG_AsVal_int(obj2, &val3);
32063 if (!SWIG_IsOK(ecode3)) {
32064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32065 }
32066 arg3 = static_cast< int >(val3);
32067 {
32068 PyThreadState* __tstate = wxPyBeginAllowThreads();
32069 (arg1)->SetVirtualSize(arg2,arg3);
32070 wxPyEndAllowThreads(__tstate);
32071 if (PyErr_Occurred()) SWIG_fail;
32072 }
32073 resultobj = SWIG_Py_Void();
32074 return resultobj;
32075 fail:
32076 return NULL;
32077 }
32078
32079
32080 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32081 PyObject *resultobj = 0;
32082 wxWindow *arg1 = (wxWindow *) 0 ;
32083 wxSize result;
32084 void *argp1 = 0 ;
32085 int res1 = 0 ;
32086 PyObject *swig_obj[1] ;
32087
32088 if (!args) SWIG_fail;
32089 swig_obj[0] = args;
32090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32091 if (!SWIG_IsOK(res1)) {
32092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32093 }
32094 arg1 = reinterpret_cast< wxWindow * >(argp1);
32095 {
32096 PyThreadState* __tstate = wxPyBeginAllowThreads();
32097 result = ((wxWindow const *)arg1)->GetVirtualSize();
32098 wxPyEndAllowThreads(__tstate);
32099 if (PyErr_Occurred()) SWIG_fail;
32100 }
32101 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32102 return resultobj;
32103 fail:
32104 return NULL;
32105 }
32106
32107
32108 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32109 PyObject *resultobj = 0;
32110 wxWindow *arg1 = (wxWindow *) 0 ;
32111 int *arg2 = (int *) 0 ;
32112 int *arg3 = (int *) 0 ;
32113 void *argp1 = 0 ;
32114 int res1 = 0 ;
32115 int temp2 ;
32116 int res2 = SWIG_TMPOBJ ;
32117 int temp3 ;
32118 int res3 = SWIG_TMPOBJ ;
32119 PyObject *swig_obj[1] ;
32120
32121 arg2 = &temp2;
32122 arg3 = &temp3;
32123 if (!args) SWIG_fail;
32124 swig_obj[0] = args;
32125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32126 if (!SWIG_IsOK(res1)) {
32127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32128 }
32129 arg1 = reinterpret_cast< wxWindow * >(argp1);
32130 {
32131 PyThreadState* __tstate = wxPyBeginAllowThreads();
32132 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32133 wxPyEndAllowThreads(__tstate);
32134 if (PyErr_Occurred()) SWIG_fail;
32135 }
32136 resultobj = SWIG_Py_Void();
32137 if (SWIG_IsTmpObj(res2)) {
32138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32139 } else {
32140 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32141 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32142 }
32143 if (SWIG_IsTmpObj(res3)) {
32144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32145 } else {
32146 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32147 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32148 }
32149 return resultobj;
32150 fail:
32151 return NULL;
32152 }
32153
32154
32155 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32156 PyObject *resultobj = 0;
32157 wxWindow *arg1 = (wxWindow *) 0 ;
32158 wxSize result;
32159 void *argp1 = 0 ;
32160 int res1 = 0 ;
32161 PyObject *swig_obj[1] ;
32162
32163 if (!args) SWIG_fail;
32164 swig_obj[0] = args;
32165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32166 if (!SWIG_IsOK(res1)) {
32167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32168 }
32169 arg1 = reinterpret_cast< wxWindow * >(argp1);
32170 {
32171 PyThreadState* __tstate = wxPyBeginAllowThreads();
32172 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32173 wxPyEndAllowThreads(__tstate);
32174 if (PyErr_Occurred()) SWIG_fail;
32175 }
32176 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32177 return resultobj;
32178 fail:
32179 return NULL;
32180 }
32181
32182
32183 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32184 PyObject *resultobj = 0;
32185 wxWindow *arg1 = (wxWindow *) 0 ;
32186 bool arg2 = (bool) true ;
32187 bool result;
32188 void *argp1 = 0 ;
32189 int res1 = 0 ;
32190 bool val2 ;
32191 int ecode2 = 0 ;
32192 PyObject * obj0 = 0 ;
32193 PyObject * obj1 = 0 ;
32194 char * kwnames[] = {
32195 (char *) "self",(char *) "show", NULL
32196 };
32197
32198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32200 if (!SWIG_IsOK(res1)) {
32201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32202 }
32203 arg1 = reinterpret_cast< wxWindow * >(argp1);
32204 if (obj1) {
32205 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32206 if (!SWIG_IsOK(ecode2)) {
32207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32208 }
32209 arg2 = static_cast< bool >(val2);
32210 }
32211 {
32212 PyThreadState* __tstate = wxPyBeginAllowThreads();
32213 result = (bool)(arg1)->Show(arg2);
32214 wxPyEndAllowThreads(__tstate);
32215 if (PyErr_Occurred()) SWIG_fail;
32216 }
32217 {
32218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32219 }
32220 return resultobj;
32221 fail:
32222 return NULL;
32223 }
32224
32225
32226 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32227 PyObject *resultobj = 0;
32228 wxWindow *arg1 = (wxWindow *) 0 ;
32229 bool result;
32230 void *argp1 = 0 ;
32231 int res1 = 0 ;
32232 PyObject *swig_obj[1] ;
32233
32234 if (!args) SWIG_fail;
32235 swig_obj[0] = args;
32236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32237 if (!SWIG_IsOK(res1)) {
32238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32239 }
32240 arg1 = reinterpret_cast< wxWindow * >(argp1);
32241 {
32242 PyThreadState* __tstate = wxPyBeginAllowThreads();
32243 result = (bool)(arg1)->Hide();
32244 wxPyEndAllowThreads(__tstate);
32245 if (PyErr_Occurred()) SWIG_fail;
32246 }
32247 {
32248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32249 }
32250 return resultobj;
32251 fail:
32252 return NULL;
32253 }
32254
32255
32256 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32257 PyObject *resultobj = 0;
32258 wxWindow *arg1 = (wxWindow *) 0 ;
32259 bool arg2 = (bool) true ;
32260 bool result;
32261 void *argp1 = 0 ;
32262 int res1 = 0 ;
32263 bool val2 ;
32264 int ecode2 = 0 ;
32265 PyObject * obj0 = 0 ;
32266 PyObject * obj1 = 0 ;
32267 char * kwnames[] = {
32268 (char *) "self",(char *) "enable", NULL
32269 };
32270
32271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32273 if (!SWIG_IsOK(res1)) {
32274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32275 }
32276 arg1 = reinterpret_cast< wxWindow * >(argp1);
32277 if (obj1) {
32278 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32279 if (!SWIG_IsOK(ecode2)) {
32280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32281 }
32282 arg2 = static_cast< bool >(val2);
32283 }
32284 {
32285 PyThreadState* __tstate = wxPyBeginAllowThreads();
32286 result = (bool)(arg1)->Enable(arg2);
32287 wxPyEndAllowThreads(__tstate);
32288 if (PyErr_Occurred()) SWIG_fail;
32289 }
32290 {
32291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32292 }
32293 return resultobj;
32294 fail:
32295 return NULL;
32296 }
32297
32298
32299 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32300 PyObject *resultobj = 0;
32301 wxWindow *arg1 = (wxWindow *) 0 ;
32302 bool result;
32303 void *argp1 = 0 ;
32304 int res1 = 0 ;
32305 PyObject *swig_obj[1] ;
32306
32307 if (!args) SWIG_fail;
32308 swig_obj[0] = args;
32309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32310 if (!SWIG_IsOK(res1)) {
32311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32312 }
32313 arg1 = reinterpret_cast< wxWindow * >(argp1);
32314 {
32315 PyThreadState* __tstate = wxPyBeginAllowThreads();
32316 result = (bool)(arg1)->Disable();
32317 wxPyEndAllowThreads(__tstate);
32318 if (PyErr_Occurred()) SWIG_fail;
32319 }
32320 {
32321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32322 }
32323 return resultobj;
32324 fail:
32325 return NULL;
32326 }
32327
32328
32329 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32330 PyObject *resultobj = 0;
32331 wxWindow *arg1 = (wxWindow *) 0 ;
32332 bool result;
32333 void *argp1 = 0 ;
32334 int res1 = 0 ;
32335 PyObject *swig_obj[1] ;
32336
32337 if (!args) SWIG_fail;
32338 swig_obj[0] = args;
32339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32340 if (!SWIG_IsOK(res1)) {
32341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32342 }
32343 arg1 = reinterpret_cast< wxWindow * >(argp1);
32344 {
32345 PyThreadState* __tstate = wxPyBeginAllowThreads();
32346 result = (bool)((wxWindow const *)arg1)->IsShown();
32347 wxPyEndAllowThreads(__tstate);
32348 if (PyErr_Occurred()) SWIG_fail;
32349 }
32350 {
32351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32352 }
32353 return resultobj;
32354 fail:
32355 return NULL;
32356 }
32357
32358
32359 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32360 PyObject *resultobj = 0;
32361 wxWindow *arg1 = (wxWindow *) 0 ;
32362 bool result;
32363 void *argp1 = 0 ;
32364 int res1 = 0 ;
32365 PyObject *swig_obj[1] ;
32366
32367 if (!args) SWIG_fail;
32368 swig_obj[0] = args;
32369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32370 if (!SWIG_IsOK(res1)) {
32371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32372 }
32373 arg1 = reinterpret_cast< wxWindow * >(argp1);
32374 {
32375 PyThreadState* __tstate = wxPyBeginAllowThreads();
32376 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32377 wxPyEndAllowThreads(__tstate);
32378 if (PyErr_Occurred()) SWIG_fail;
32379 }
32380 {
32381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32382 }
32383 return resultobj;
32384 fail:
32385 return NULL;
32386 }
32387
32388
32389 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32390 PyObject *resultobj = 0;
32391 wxWindow *arg1 = (wxWindow *) 0 ;
32392 long arg2 ;
32393 void *argp1 = 0 ;
32394 int res1 = 0 ;
32395 long val2 ;
32396 int ecode2 = 0 ;
32397 PyObject * obj0 = 0 ;
32398 PyObject * obj1 = 0 ;
32399 char * kwnames[] = {
32400 (char *) "self",(char *) "style", NULL
32401 };
32402
32403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32405 if (!SWIG_IsOK(res1)) {
32406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32407 }
32408 arg1 = reinterpret_cast< wxWindow * >(argp1);
32409 ecode2 = SWIG_AsVal_long(obj1, &val2);
32410 if (!SWIG_IsOK(ecode2)) {
32411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32412 }
32413 arg2 = static_cast< long >(val2);
32414 {
32415 PyThreadState* __tstate = wxPyBeginAllowThreads();
32416 (arg1)->SetWindowStyleFlag(arg2);
32417 wxPyEndAllowThreads(__tstate);
32418 if (PyErr_Occurred()) SWIG_fail;
32419 }
32420 resultobj = SWIG_Py_Void();
32421 return resultobj;
32422 fail:
32423 return NULL;
32424 }
32425
32426
32427 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32428 PyObject *resultobj = 0;
32429 wxWindow *arg1 = (wxWindow *) 0 ;
32430 long result;
32431 void *argp1 = 0 ;
32432 int res1 = 0 ;
32433 PyObject *swig_obj[1] ;
32434
32435 if (!args) SWIG_fail;
32436 swig_obj[0] = args;
32437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32438 if (!SWIG_IsOK(res1)) {
32439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32440 }
32441 arg1 = reinterpret_cast< wxWindow * >(argp1);
32442 {
32443 PyThreadState* __tstate = wxPyBeginAllowThreads();
32444 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32445 wxPyEndAllowThreads(__tstate);
32446 if (PyErr_Occurred()) SWIG_fail;
32447 }
32448 resultobj = SWIG_From_long(static_cast< long >(result));
32449 return resultobj;
32450 fail:
32451 return NULL;
32452 }
32453
32454
32455 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32456 PyObject *resultobj = 0;
32457 wxWindow *arg1 = (wxWindow *) 0 ;
32458 int arg2 ;
32459 bool result;
32460 void *argp1 = 0 ;
32461 int res1 = 0 ;
32462 int val2 ;
32463 int ecode2 = 0 ;
32464 PyObject * obj0 = 0 ;
32465 PyObject * obj1 = 0 ;
32466 char * kwnames[] = {
32467 (char *) "self",(char *) "flag", NULL
32468 };
32469
32470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32472 if (!SWIG_IsOK(res1)) {
32473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32474 }
32475 arg1 = reinterpret_cast< wxWindow * >(argp1);
32476 ecode2 = SWIG_AsVal_int(obj1, &val2);
32477 if (!SWIG_IsOK(ecode2)) {
32478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32479 }
32480 arg2 = static_cast< int >(val2);
32481 {
32482 PyThreadState* __tstate = wxPyBeginAllowThreads();
32483 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32484 wxPyEndAllowThreads(__tstate);
32485 if (PyErr_Occurred()) SWIG_fail;
32486 }
32487 {
32488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32489 }
32490 return resultobj;
32491 fail:
32492 return NULL;
32493 }
32494
32495
32496 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32497 PyObject *resultobj = 0;
32498 wxWindow *arg1 = (wxWindow *) 0 ;
32499 bool result;
32500 void *argp1 = 0 ;
32501 int res1 = 0 ;
32502 PyObject *swig_obj[1] ;
32503
32504 if (!args) SWIG_fail;
32505 swig_obj[0] = args;
32506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32507 if (!SWIG_IsOK(res1)) {
32508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32509 }
32510 arg1 = reinterpret_cast< wxWindow * >(argp1);
32511 {
32512 PyThreadState* __tstate = wxPyBeginAllowThreads();
32513 result = (bool)((wxWindow const *)arg1)->IsRetained();
32514 wxPyEndAllowThreads(__tstate);
32515 if (PyErr_Occurred()) SWIG_fail;
32516 }
32517 {
32518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32519 }
32520 return resultobj;
32521 fail:
32522 return NULL;
32523 }
32524
32525
32526 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32527 PyObject *resultobj = 0;
32528 wxWindow *arg1 = (wxWindow *) 0 ;
32529 long arg2 ;
32530 void *argp1 = 0 ;
32531 int res1 = 0 ;
32532 long val2 ;
32533 int ecode2 = 0 ;
32534 PyObject * obj0 = 0 ;
32535 PyObject * obj1 = 0 ;
32536 char * kwnames[] = {
32537 (char *) "self",(char *) "exStyle", NULL
32538 };
32539
32540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32542 if (!SWIG_IsOK(res1)) {
32543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32544 }
32545 arg1 = reinterpret_cast< wxWindow * >(argp1);
32546 ecode2 = SWIG_AsVal_long(obj1, &val2);
32547 if (!SWIG_IsOK(ecode2)) {
32548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32549 }
32550 arg2 = static_cast< long >(val2);
32551 {
32552 PyThreadState* __tstate = wxPyBeginAllowThreads();
32553 (arg1)->SetExtraStyle(arg2);
32554 wxPyEndAllowThreads(__tstate);
32555 if (PyErr_Occurred()) SWIG_fail;
32556 }
32557 resultobj = SWIG_Py_Void();
32558 return resultobj;
32559 fail:
32560 return NULL;
32561 }
32562
32563
32564 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32565 PyObject *resultobj = 0;
32566 wxWindow *arg1 = (wxWindow *) 0 ;
32567 long result;
32568 void *argp1 = 0 ;
32569 int res1 = 0 ;
32570 PyObject *swig_obj[1] ;
32571
32572 if (!args) SWIG_fail;
32573 swig_obj[0] = args;
32574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32575 if (!SWIG_IsOK(res1)) {
32576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32577 }
32578 arg1 = reinterpret_cast< wxWindow * >(argp1);
32579 {
32580 PyThreadState* __tstate = wxPyBeginAllowThreads();
32581 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32582 wxPyEndAllowThreads(__tstate);
32583 if (PyErr_Occurred()) SWIG_fail;
32584 }
32585 resultobj = SWIG_From_long(static_cast< long >(result));
32586 return resultobj;
32587 fail:
32588 return NULL;
32589 }
32590
32591
32592 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32593 PyObject *resultobj = 0;
32594 wxWindow *arg1 = (wxWindow *) 0 ;
32595 bool arg2 = (bool) true ;
32596 void *argp1 = 0 ;
32597 int res1 = 0 ;
32598 bool val2 ;
32599 int ecode2 = 0 ;
32600 PyObject * obj0 = 0 ;
32601 PyObject * obj1 = 0 ;
32602 char * kwnames[] = {
32603 (char *) "self",(char *) "modal", NULL
32604 };
32605
32606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32608 if (!SWIG_IsOK(res1)) {
32609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32610 }
32611 arg1 = reinterpret_cast< wxWindow * >(argp1);
32612 if (obj1) {
32613 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32614 if (!SWIG_IsOK(ecode2)) {
32615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32616 }
32617 arg2 = static_cast< bool >(val2);
32618 }
32619 {
32620 PyThreadState* __tstate = wxPyBeginAllowThreads();
32621 (arg1)->MakeModal(arg2);
32622 wxPyEndAllowThreads(__tstate);
32623 if (PyErr_Occurred()) SWIG_fail;
32624 }
32625 resultobj = SWIG_Py_Void();
32626 return resultobj;
32627 fail:
32628 return NULL;
32629 }
32630
32631
32632 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32633 PyObject *resultobj = 0;
32634 wxWindow *arg1 = (wxWindow *) 0 ;
32635 bool arg2 ;
32636 void *argp1 = 0 ;
32637 int res1 = 0 ;
32638 bool val2 ;
32639 int ecode2 = 0 ;
32640 PyObject * obj0 = 0 ;
32641 PyObject * obj1 = 0 ;
32642 char * kwnames[] = {
32643 (char *) "self",(char *) "enableTheme", NULL
32644 };
32645
32646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32648 if (!SWIG_IsOK(res1)) {
32649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32650 }
32651 arg1 = reinterpret_cast< wxWindow * >(argp1);
32652 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32653 if (!SWIG_IsOK(ecode2)) {
32654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32655 }
32656 arg2 = static_cast< bool >(val2);
32657 {
32658 PyThreadState* __tstate = wxPyBeginAllowThreads();
32659 (arg1)->SetThemeEnabled(arg2);
32660 wxPyEndAllowThreads(__tstate);
32661 if (PyErr_Occurred()) SWIG_fail;
32662 }
32663 resultobj = SWIG_Py_Void();
32664 return resultobj;
32665 fail:
32666 return NULL;
32667 }
32668
32669
32670 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32671 PyObject *resultobj = 0;
32672 wxWindow *arg1 = (wxWindow *) 0 ;
32673 bool result;
32674 void *argp1 = 0 ;
32675 int res1 = 0 ;
32676 PyObject *swig_obj[1] ;
32677
32678 if (!args) SWIG_fail;
32679 swig_obj[0] = args;
32680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32681 if (!SWIG_IsOK(res1)) {
32682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32683 }
32684 arg1 = reinterpret_cast< wxWindow * >(argp1);
32685 {
32686 PyThreadState* __tstate = wxPyBeginAllowThreads();
32687 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32688 wxPyEndAllowThreads(__tstate);
32689 if (PyErr_Occurred()) SWIG_fail;
32690 }
32691 {
32692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32693 }
32694 return resultobj;
32695 fail:
32696 return NULL;
32697 }
32698
32699
32700 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32701 PyObject *resultobj = 0;
32702 wxWindow *arg1 = (wxWindow *) 0 ;
32703 void *argp1 = 0 ;
32704 int res1 = 0 ;
32705 PyObject *swig_obj[1] ;
32706
32707 if (!args) SWIG_fail;
32708 swig_obj[0] = args;
32709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32710 if (!SWIG_IsOK(res1)) {
32711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32712 }
32713 arg1 = reinterpret_cast< wxWindow * >(argp1);
32714 {
32715 PyThreadState* __tstate = wxPyBeginAllowThreads();
32716 (arg1)->SetFocus();
32717 wxPyEndAllowThreads(__tstate);
32718 if (PyErr_Occurred()) SWIG_fail;
32719 }
32720 resultobj = SWIG_Py_Void();
32721 return resultobj;
32722 fail:
32723 return NULL;
32724 }
32725
32726
32727 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32728 PyObject *resultobj = 0;
32729 wxWindow *arg1 = (wxWindow *) 0 ;
32730 void *argp1 = 0 ;
32731 int res1 = 0 ;
32732 PyObject *swig_obj[1] ;
32733
32734 if (!args) SWIG_fail;
32735 swig_obj[0] = args;
32736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32737 if (!SWIG_IsOK(res1)) {
32738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32739 }
32740 arg1 = reinterpret_cast< wxWindow * >(argp1);
32741 {
32742 PyThreadState* __tstate = wxPyBeginAllowThreads();
32743 (arg1)->SetFocusFromKbd();
32744 wxPyEndAllowThreads(__tstate);
32745 if (PyErr_Occurred()) SWIG_fail;
32746 }
32747 resultobj = SWIG_Py_Void();
32748 return resultobj;
32749 fail:
32750 return NULL;
32751 }
32752
32753
32754 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32755 PyObject *resultobj = 0;
32756 wxWindow *result = 0 ;
32757
32758 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32759 {
32760 if (!wxPyCheckForApp()) SWIG_fail;
32761 PyThreadState* __tstate = wxPyBeginAllowThreads();
32762 result = (wxWindow *)wxWindow::FindFocus();
32763 wxPyEndAllowThreads(__tstate);
32764 if (PyErr_Occurred()) SWIG_fail;
32765 }
32766 {
32767 resultobj = wxPyMake_wxObject(result, 0);
32768 }
32769 return resultobj;
32770 fail:
32771 return NULL;
32772 }
32773
32774
32775 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32776 PyObject *resultobj = 0;
32777 wxWindow *arg1 = (wxWindow *) 0 ;
32778 bool result;
32779 void *argp1 = 0 ;
32780 int res1 = 0 ;
32781 PyObject *swig_obj[1] ;
32782
32783 if (!args) SWIG_fail;
32784 swig_obj[0] = args;
32785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32786 if (!SWIG_IsOK(res1)) {
32787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32788 }
32789 arg1 = reinterpret_cast< wxWindow * >(argp1);
32790 {
32791 PyThreadState* __tstate = wxPyBeginAllowThreads();
32792 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32793 wxPyEndAllowThreads(__tstate);
32794 if (PyErr_Occurred()) SWIG_fail;
32795 }
32796 {
32797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32798 }
32799 return resultobj;
32800 fail:
32801 return NULL;
32802 }
32803
32804
32805 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32806 PyObject *resultobj = 0;
32807 wxWindow *arg1 = (wxWindow *) 0 ;
32808 bool result;
32809 void *argp1 = 0 ;
32810 int res1 = 0 ;
32811 PyObject *swig_obj[1] ;
32812
32813 if (!args) SWIG_fail;
32814 swig_obj[0] = args;
32815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32816 if (!SWIG_IsOK(res1)) {
32817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32818 }
32819 arg1 = reinterpret_cast< wxWindow * >(argp1);
32820 {
32821 PyThreadState* __tstate = wxPyBeginAllowThreads();
32822 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32823 wxPyEndAllowThreads(__tstate);
32824 if (PyErr_Occurred()) SWIG_fail;
32825 }
32826 {
32827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32828 }
32829 return resultobj;
32830 fail:
32831 return NULL;
32832 }
32833
32834
32835 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32836 PyObject *resultobj = 0;
32837 wxWindow *arg1 = (wxWindow *) 0 ;
32838 wxWindow *result = 0 ;
32839 void *argp1 = 0 ;
32840 int res1 = 0 ;
32841 PyObject *swig_obj[1] ;
32842
32843 if (!args) SWIG_fail;
32844 swig_obj[0] = args;
32845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32846 if (!SWIG_IsOK(res1)) {
32847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32848 }
32849 arg1 = reinterpret_cast< wxWindow * >(argp1);
32850 {
32851 PyThreadState* __tstate = wxPyBeginAllowThreads();
32852 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32853 wxPyEndAllowThreads(__tstate);
32854 if (PyErr_Occurred()) SWIG_fail;
32855 }
32856 {
32857 resultobj = wxPyMake_wxObject(result, 0);
32858 }
32859 return resultobj;
32860 fail:
32861 return NULL;
32862 }
32863
32864
32865 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32866 PyObject *resultobj = 0;
32867 wxWindow *arg1 = (wxWindow *) 0 ;
32868 wxWindow *arg2 = (wxWindow *) 0 ;
32869 wxWindow *result = 0 ;
32870 void *argp1 = 0 ;
32871 int res1 = 0 ;
32872 void *argp2 = 0 ;
32873 int res2 = 0 ;
32874 PyObject * obj0 = 0 ;
32875 PyObject * obj1 = 0 ;
32876 char * kwnames[] = {
32877 (char *) "self",(char *) "child", NULL
32878 };
32879
32880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32882 if (!SWIG_IsOK(res1)) {
32883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32884 }
32885 arg1 = reinterpret_cast< wxWindow * >(argp1);
32886 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32887 if (!SWIG_IsOK(res2)) {
32888 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32889 }
32890 arg2 = reinterpret_cast< wxWindow * >(argp2);
32891 {
32892 PyThreadState* __tstate = wxPyBeginAllowThreads();
32893 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32894 wxPyEndAllowThreads(__tstate);
32895 if (PyErr_Occurred()) SWIG_fail;
32896 }
32897 {
32898 resultobj = wxPyMake_wxObject(result, 0);
32899 }
32900 return resultobj;
32901 fail:
32902 return NULL;
32903 }
32904
32905
32906 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32907 PyObject *resultobj = 0;
32908 wxWindow *arg1 = (wxWindow *) 0 ;
32909 wxWindow *arg2 = (wxWindow *) 0 ;
32910 void *argp1 = 0 ;
32911 int res1 = 0 ;
32912 void *argp2 = 0 ;
32913 int res2 = 0 ;
32914 PyObject * obj0 = 0 ;
32915 PyObject * obj1 = 0 ;
32916 char * kwnames[] = {
32917 (char *) "self",(char *) "win", NULL
32918 };
32919
32920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32922 if (!SWIG_IsOK(res1)) {
32923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32924 }
32925 arg1 = reinterpret_cast< wxWindow * >(argp1);
32926 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32927 if (!SWIG_IsOK(res2)) {
32928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32929 }
32930 arg2 = reinterpret_cast< wxWindow * >(argp2);
32931 {
32932 PyThreadState* __tstate = wxPyBeginAllowThreads();
32933 (arg1)->SetTmpDefaultItem(arg2);
32934 wxPyEndAllowThreads(__tstate);
32935 if (PyErr_Occurred()) SWIG_fail;
32936 }
32937 resultobj = SWIG_Py_Void();
32938 return resultobj;
32939 fail:
32940 return NULL;
32941 }
32942
32943
32944 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32945 PyObject *resultobj = 0;
32946 wxWindow *arg1 = (wxWindow *) 0 ;
32947 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32948 bool result;
32949 void *argp1 = 0 ;
32950 int res1 = 0 ;
32951 int val2 ;
32952 int ecode2 = 0 ;
32953 PyObject * obj0 = 0 ;
32954 PyObject * obj1 = 0 ;
32955 char * kwnames[] = {
32956 (char *) "self",(char *) "flags", NULL
32957 };
32958
32959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32961 if (!SWIG_IsOK(res1)) {
32962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32963 }
32964 arg1 = reinterpret_cast< wxWindow * >(argp1);
32965 if (obj1) {
32966 ecode2 = SWIG_AsVal_int(obj1, &val2);
32967 if (!SWIG_IsOK(ecode2)) {
32968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32969 }
32970 arg2 = static_cast< int >(val2);
32971 }
32972 {
32973 PyThreadState* __tstate = wxPyBeginAllowThreads();
32974 result = (bool)(arg1)->Navigate(arg2);
32975 wxPyEndAllowThreads(__tstate);
32976 if (PyErr_Occurred()) SWIG_fail;
32977 }
32978 {
32979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32980 }
32981 return resultobj;
32982 fail:
32983 return NULL;
32984 }
32985
32986
32987 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32988 PyObject *resultobj = 0;
32989 wxWindow *arg1 = (wxWindow *) 0 ;
32990 wxWindow *arg2 = (wxWindow *) 0 ;
32991 void *argp1 = 0 ;
32992 int res1 = 0 ;
32993 void *argp2 = 0 ;
32994 int res2 = 0 ;
32995 PyObject * obj0 = 0 ;
32996 PyObject * obj1 = 0 ;
32997 char * kwnames[] = {
32998 (char *) "self",(char *) "win", NULL
32999 };
33000
33001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33003 if (!SWIG_IsOK(res1)) {
33004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33005 }
33006 arg1 = reinterpret_cast< wxWindow * >(argp1);
33007 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33008 if (!SWIG_IsOK(res2)) {
33009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33010 }
33011 arg2 = reinterpret_cast< wxWindow * >(argp2);
33012 {
33013 PyThreadState* __tstate = wxPyBeginAllowThreads();
33014 (arg1)->MoveAfterInTabOrder(arg2);
33015 wxPyEndAllowThreads(__tstate);
33016 if (PyErr_Occurred()) SWIG_fail;
33017 }
33018 resultobj = SWIG_Py_Void();
33019 return resultobj;
33020 fail:
33021 return NULL;
33022 }
33023
33024
33025 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33026 PyObject *resultobj = 0;
33027 wxWindow *arg1 = (wxWindow *) 0 ;
33028 wxWindow *arg2 = (wxWindow *) 0 ;
33029 void *argp1 = 0 ;
33030 int res1 = 0 ;
33031 void *argp2 = 0 ;
33032 int res2 = 0 ;
33033 PyObject * obj0 = 0 ;
33034 PyObject * obj1 = 0 ;
33035 char * kwnames[] = {
33036 (char *) "self",(char *) "win", NULL
33037 };
33038
33039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33041 if (!SWIG_IsOK(res1)) {
33042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33043 }
33044 arg1 = reinterpret_cast< wxWindow * >(argp1);
33045 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33046 if (!SWIG_IsOK(res2)) {
33047 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33048 }
33049 arg2 = reinterpret_cast< wxWindow * >(argp2);
33050 {
33051 PyThreadState* __tstate = wxPyBeginAllowThreads();
33052 (arg1)->MoveBeforeInTabOrder(arg2);
33053 wxPyEndAllowThreads(__tstate);
33054 if (PyErr_Occurred()) SWIG_fail;
33055 }
33056 resultobj = SWIG_Py_Void();
33057 return resultobj;
33058 fail:
33059 return NULL;
33060 }
33061
33062
33063 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33064 PyObject *resultobj = 0;
33065 wxWindow *arg1 = (wxWindow *) 0 ;
33066 PyObject *result = 0 ;
33067 void *argp1 = 0 ;
33068 int res1 = 0 ;
33069 PyObject *swig_obj[1] ;
33070
33071 if (!args) SWIG_fail;
33072 swig_obj[0] = args;
33073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33074 if (!SWIG_IsOK(res1)) {
33075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33076 }
33077 arg1 = reinterpret_cast< wxWindow * >(argp1);
33078 {
33079 PyThreadState* __tstate = wxPyBeginAllowThreads();
33080 result = (PyObject *)wxWindow_GetChildren(arg1);
33081 wxPyEndAllowThreads(__tstate);
33082 if (PyErr_Occurred()) SWIG_fail;
33083 }
33084 resultobj = result;
33085 return resultobj;
33086 fail:
33087 return NULL;
33088 }
33089
33090
33091 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33092 PyObject *resultobj = 0;
33093 wxWindow *arg1 = (wxWindow *) 0 ;
33094 wxWindow *result = 0 ;
33095 void *argp1 = 0 ;
33096 int res1 = 0 ;
33097 PyObject *swig_obj[1] ;
33098
33099 if (!args) SWIG_fail;
33100 swig_obj[0] = args;
33101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33102 if (!SWIG_IsOK(res1)) {
33103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33104 }
33105 arg1 = reinterpret_cast< wxWindow * >(argp1);
33106 {
33107 PyThreadState* __tstate = wxPyBeginAllowThreads();
33108 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33109 wxPyEndAllowThreads(__tstate);
33110 if (PyErr_Occurred()) SWIG_fail;
33111 }
33112 {
33113 resultobj = wxPyMake_wxObject(result, 0);
33114 }
33115 return resultobj;
33116 fail:
33117 return NULL;
33118 }
33119
33120
33121 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33122 PyObject *resultobj = 0;
33123 wxWindow *arg1 = (wxWindow *) 0 ;
33124 wxWindow *result = 0 ;
33125 void *argp1 = 0 ;
33126 int res1 = 0 ;
33127 PyObject *swig_obj[1] ;
33128
33129 if (!args) SWIG_fail;
33130 swig_obj[0] = args;
33131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33132 if (!SWIG_IsOK(res1)) {
33133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33134 }
33135 arg1 = reinterpret_cast< wxWindow * >(argp1);
33136 {
33137 PyThreadState* __tstate = wxPyBeginAllowThreads();
33138 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33139 wxPyEndAllowThreads(__tstate);
33140 if (PyErr_Occurred()) SWIG_fail;
33141 }
33142 {
33143 resultobj = wxPyMake_wxObject(result, 0);
33144 }
33145 return resultobj;
33146 fail:
33147 return NULL;
33148 }
33149
33150
33151 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33152 PyObject *resultobj = 0;
33153 wxWindow *arg1 = (wxWindow *) 0 ;
33154 bool result;
33155 void *argp1 = 0 ;
33156 int res1 = 0 ;
33157 PyObject *swig_obj[1] ;
33158
33159 if (!args) SWIG_fail;
33160 swig_obj[0] = args;
33161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33162 if (!SWIG_IsOK(res1)) {
33163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33164 }
33165 arg1 = reinterpret_cast< wxWindow * >(argp1);
33166 {
33167 PyThreadState* __tstate = wxPyBeginAllowThreads();
33168 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33169 wxPyEndAllowThreads(__tstate);
33170 if (PyErr_Occurred()) SWIG_fail;
33171 }
33172 {
33173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33174 }
33175 return resultobj;
33176 fail:
33177 return NULL;
33178 }
33179
33180
33181 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33182 PyObject *resultobj = 0;
33183 wxWindow *arg1 = (wxWindow *) 0 ;
33184 wxWindow *arg2 = (wxWindow *) 0 ;
33185 bool result;
33186 void *argp1 = 0 ;
33187 int res1 = 0 ;
33188 void *argp2 = 0 ;
33189 int res2 = 0 ;
33190 PyObject * obj0 = 0 ;
33191 PyObject * obj1 = 0 ;
33192 char * kwnames[] = {
33193 (char *) "self",(char *) "newParent", NULL
33194 };
33195
33196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33198 if (!SWIG_IsOK(res1)) {
33199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33200 }
33201 arg1 = reinterpret_cast< wxWindow * >(argp1);
33202 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33203 if (!SWIG_IsOK(res2)) {
33204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33205 }
33206 arg2 = reinterpret_cast< wxWindow * >(argp2);
33207 {
33208 PyThreadState* __tstate = wxPyBeginAllowThreads();
33209 result = (bool)(arg1)->Reparent(arg2);
33210 wxPyEndAllowThreads(__tstate);
33211 if (PyErr_Occurred()) SWIG_fail;
33212 }
33213 {
33214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33215 }
33216 return resultobj;
33217 fail:
33218 return NULL;
33219 }
33220
33221
33222 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33223 PyObject *resultobj = 0;
33224 wxWindow *arg1 = (wxWindow *) 0 ;
33225 wxWindow *arg2 = (wxWindow *) 0 ;
33226 void *argp1 = 0 ;
33227 int res1 = 0 ;
33228 void *argp2 = 0 ;
33229 int res2 = 0 ;
33230 PyObject * obj0 = 0 ;
33231 PyObject * obj1 = 0 ;
33232 char * kwnames[] = {
33233 (char *) "self",(char *) "child", NULL
33234 };
33235
33236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33238 if (!SWIG_IsOK(res1)) {
33239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33240 }
33241 arg1 = reinterpret_cast< wxWindow * >(argp1);
33242 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33243 if (!SWIG_IsOK(res2)) {
33244 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33245 }
33246 arg2 = reinterpret_cast< wxWindow * >(argp2);
33247 {
33248 PyThreadState* __tstate = wxPyBeginAllowThreads();
33249 (arg1)->AddChild(arg2);
33250 wxPyEndAllowThreads(__tstate);
33251 if (PyErr_Occurred()) SWIG_fail;
33252 }
33253 resultobj = SWIG_Py_Void();
33254 return resultobj;
33255 fail:
33256 return NULL;
33257 }
33258
33259
33260 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33261 PyObject *resultobj = 0;
33262 wxWindow *arg1 = (wxWindow *) 0 ;
33263 wxWindow *arg2 = (wxWindow *) 0 ;
33264 void *argp1 = 0 ;
33265 int res1 = 0 ;
33266 void *argp2 = 0 ;
33267 int res2 = 0 ;
33268 PyObject * obj0 = 0 ;
33269 PyObject * obj1 = 0 ;
33270 char * kwnames[] = {
33271 (char *) "self",(char *) "child", NULL
33272 };
33273
33274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33276 if (!SWIG_IsOK(res1)) {
33277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33278 }
33279 arg1 = reinterpret_cast< wxWindow * >(argp1);
33280 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33281 if (!SWIG_IsOK(res2)) {
33282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33283 }
33284 arg2 = reinterpret_cast< wxWindow * >(argp2);
33285 {
33286 PyThreadState* __tstate = wxPyBeginAllowThreads();
33287 (arg1)->RemoveChild(arg2);
33288 wxPyEndAllowThreads(__tstate);
33289 if (PyErr_Occurred()) SWIG_fail;
33290 }
33291 resultobj = SWIG_Py_Void();
33292 return resultobj;
33293 fail:
33294 return NULL;
33295 }
33296
33297
33298 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33299 PyObject *resultobj = 0;
33300 wxWindow *arg1 = (wxWindow *) 0 ;
33301 bool arg2 ;
33302 void *argp1 = 0 ;
33303 int res1 = 0 ;
33304 bool val2 ;
33305 int ecode2 = 0 ;
33306 PyObject * obj0 = 0 ;
33307 PyObject * obj1 = 0 ;
33308 char * kwnames[] = {
33309 (char *) "self",(char *) "on", NULL
33310 };
33311
33312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33314 if (!SWIG_IsOK(res1)) {
33315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33316 }
33317 arg1 = reinterpret_cast< wxWindow * >(argp1);
33318 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33319 if (!SWIG_IsOK(ecode2)) {
33320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33321 }
33322 arg2 = static_cast< bool >(val2);
33323 {
33324 PyThreadState* __tstate = wxPyBeginAllowThreads();
33325 wxWindow_SetDoubleBuffered(arg1,arg2);
33326 wxPyEndAllowThreads(__tstate);
33327 if (PyErr_Occurred()) SWIG_fail;
33328 }
33329 resultobj = SWIG_Py_Void();
33330 return resultobj;
33331 fail:
33332 return NULL;
33333 }
33334
33335
33336 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33337 PyObject *resultobj = 0;
33338 wxWindow *arg1 = (wxWindow *) 0 ;
33339 long arg2 ;
33340 wxWindow *result = 0 ;
33341 void *argp1 = 0 ;
33342 int res1 = 0 ;
33343 long val2 ;
33344 int ecode2 = 0 ;
33345 PyObject * obj0 = 0 ;
33346 PyObject * obj1 = 0 ;
33347 char * kwnames[] = {
33348 (char *) "self",(char *) "winid", NULL
33349 };
33350
33351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33353 if (!SWIG_IsOK(res1)) {
33354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33355 }
33356 arg1 = reinterpret_cast< wxWindow * >(argp1);
33357 ecode2 = SWIG_AsVal_long(obj1, &val2);
33358 if (!SWIG_IsOK(ecode2)) {
33359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33360 }
33361 arg2 = static_cast< long >(val2);
33362 {
33363 PyThreadState* __tstate = wxPyBeginAllowThreads();
33364 result = (wxWindow *)(arg1)->FindWindow(arg2);
33365 wxPyEndAllowThreads(__tstate);
33366 if (PyErr_Occurred()) SWIG_fail;
33367 }
33368 {
33369 resultobj = wxPyMake_wxObject(result, 0);
33370 }
33371 return resultobj;
33372 fail:
33373 return NULL;
33374 }
33375
33376
33377 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33378 PyObject *resultobj = 0;
33379 wxWindow *arg1 = (wxWindow *) 0 ;
33380 wxString *arg2 = 0 ;
33381 wxWindow *result = 0 ;
33382 void *argp1 = 0 ;
33383 int res1 = 0 ;
33384 bool temp2 = false ;
33385 PyObject * obj0 = 0 ;
33386 PyObject * obj1 = 0 ;
33387 char * kwnames[] = {
33388 (char *) "self",(char *) "name", NULL
33389 };
33390
33391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33393 if (!SWIG_IsOK(res1)) {
33394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33395 }
33396 arg1 = reinterpret_cast< wxWindow * >(argp1);
33397 {
33398 arg2 = wxString_in_helper(obj1);
33399 if (arg2 == NULL) SWIG_fail;
33400 temp2 = true;
33401 }
33402 {
33403 PyThreadState* __tstate = wxPyBeginAllowThreads();
33404 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33405 wxPyEndAllowThreads(__tstate);
33406 if (PyErr_Occurred()) SWIG_fail;
33407 }
33408 {
33409 resultobj = wxPyMake_wxObject(result, 0);
33410 }
33411 {
33412 if (temp2)
33413 delete arg2;
33414 }
33415 return resultobj;
33416 fail:
33417 {
33418 if (temp2)
33419 delete arg2;
33420 }
33421 return NULL;
33422 }
33423
33424
33425 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33426 PyObject *resultobj = 0;
33427 wxWindow *arg1 = (wxWindow *) 0 ;
33428 wxEvtHandler *result = 0 ;
33429 void *argp1 = 0 ;
33430 int res1 = 0 ;
33431 PyObject *swig_obj[1] ;
33432
33433 if (!args) SWIG_fail;
33434 swig_obj[0] = args;
33435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33436 if (!SWIG_IsOK(res1)) {
33437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33438 }
33439 arg1 = reinterpret_cast< wxWindow * >(argp1);
33440 {
33441 PyThreadState* __tstate = wxPyBeginAllowThreads();
33442 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33443 wxPyEndAllowThreads(__tstate);
33444 if (PyErr_Occurred()) SWIG_fail;
33445 }
33446 {
33447 resultobj = wxPyMake_wxObject(result, 0);
33448 }
33449 return resultobj;
33450 fail:
33451 return NULL;
33452 }
33453
33454
33455 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33456 PyObject *resultobj = 0;
33457 wxWindow *arg1 = (wxWindow *) 0 ;
33458 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33459 void *argp1 = 0 ;
33460 int res1 = 0 ;
33461 void *argp2 = 0 ;
33462 int res2 = 0 ;
33463 PyObject * obj0 = 0 ;
33464 PyObject * obj1 = 0 ;
33465 char * kwnames[] = {
33466 (char *) "self",(char *) "handler", NULL
33467 };
33468
33469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33471 if (!SWIG_IsOK(res1)) {
33472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33473 }
33474 arg1 = reinterpret_cast< wxWindow * >(argp1);
33475 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33476 if (!SWIG_IsOK(res2)) {
33477 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33478 }
33479 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33480 {
33481 PyThreadState* __tstate = wxPyBeginAllowThreads();
33482 (arg1)->SetEventHandler(arg2);
33483 wxPyEndAllowThreads(__tstate);
33484 if (PyErr_Occurred()) SWIG_fail;
33485 }
33486 resultobj = SWIG_Py_Void();
33487 return resultobj;
33488 fail:
33489 return NULL;
33490 }
33491
33492
33493 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33494 PyObject *resultobj = 0;
33495 wxWindow *arg1 = (wxWindow *) 0 ;
33496 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33497 void *argp1 = 0 ;
33498 int res1 = 0 ;
33499 void *argp2 = 0 ;
33500 int res2 = 0 ;
33501 PyObject * obj0 = 0 ;
33502 PyObject * obj1 = 0 ;
33503 char * kwnames[] = {
33504 (char *) "self",(char *) "handler", NULL
33505 };
33506
33507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33509 if (!SWIG_IsOK(res1)) {
33510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33511 }
33512 arg1 = reinterpret_cast< wxWindow * >(argp1);
33513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33514 if (!SWIG_IsOK(res2)) {
33515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33516 }
33517 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33518 {
33519 PyThreadState* __tstate = wxPyBeginAllowThreads();
33520 (arg1)->PushEventHandler(arg2);
33521 wxPyEndAllowThreads(__tstate);
33522 if (PyErr_Occurred()) SWIG_fail;
33523 }
33524 resultobj = SWIG_Py_Void();
33525 return resultobj;
33526 fail:
33527 return NULL;
33528 }
33529
33530
33531 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33532 PyObject *resultobj = 0;
33533 wxWindow *arg1 = (wxWindow *) 0 ;
33534 bool arg2 = (bool) false ;
33535 wxEvtHandler *result = 0 ;
33536 void *argp1 = 0 ;
33537 int res1 = 0 ;
33538 bool val2 ;
33539 int ecode2 = 0 ;
33540 PyObject * obj0 = 0 ;
33541 PyObject * obj1 = 0 ;
33542 char * kwnames[] = {
33543 (char *) "self",(char *) "deleteHandler", NULL
33544 };
33545
33546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33548 if (!SWIG_IsOK(res1)) {
33549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33550 }
33551 arg1 = reinterpret_cast< wxWindow * >(argp1);
33552 if (obj1) {
33553 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33554 if (!SWIG_IsOK(ecode2)) {
33555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33556 }
33557 arg2 = static_cast< bool >(val2);
33558 }
33559 {
33560 PyThreadState* __tstate = wxPyBeginAllowThreads();
33561 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33562 wxPyEndAllowThreads(__tstate);
33563 if (PyErr_Occurred()) SWIG_fail;
33564 }
33565 {
33566 resultobj = wxPyMake_wxObject(result, 0);
33567 }
33568 return resultobj;
33569 fail:
33570 return NULL;
33571 }
33572
33573
33574 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33575 PyObject *resultobj = 0;
33576 wxWindow *arg1 = (wxWindow *) 0 ;
33577 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33578 bool result;
33579 void *argp1 = 0 ;
33580 int res1 = 0 ;
33581 void *argp2 = 0 ;
33582 int res2 = 0 ;
33583 PyObject * obj0 = 0 ;
33584 PyObject * obj1 = 0 ;
33585 char * kwnames[] = {
33586 (char *) "self",(char *) "handler", NULL
33587 };
33588
33589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33591 if (!SWIG_IsOK(res1)) {
33592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33593 }
33594 arg1 = reinterpret_cast< wxWindow * >(argp1);
33595 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33596 if (!SWIG_IsOK(res2)) {
33597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33598 }
33599 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33600 {
33601 PyThreadState* __tstate = wxPyBeginAllowThreads();
33602 result = (bool)(arg1)->RemoveEventHandler(arg2);
33603 wxPyEndAllowThreads(__tstate);
33604 if (PyErr_Occurred()) SWIG_fail;
33605 }
33606 {
33607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33608 }
33609 return resultobj;
33610 fail:
33611 return NULL;
33612 }
33613
33614
33615 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33616 PyObject *resultobj = 0;
33617 wxWindow *arg1 = (wxWindow *) 0 ;
33618 wxValidator *arg2 = 0 ;
33619 void *argp1 = 0 ;
33620 int res1 = 0 ;
33621 void *argp2 = 0 ;
33622 int res2 = 0 ;
33623 PyObject * obj0 = 0 ;
33624 PyObject * obj1 = 0 ;
33625 char * kwnames[] = {
33626 (char *) "self",(char *) "validator", NULL
33627 };
33628
33629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33631 if (!SWIG_IsOK(res1)) {
33632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33633 }
33634 arg1 = reinterpret_cast< wxWindow * >(argp1);
33635 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33636 if (!SWIG_IsOK(res2)) {
33637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33638 }
33639 if (!argp2) {
33640 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33641 }
33642 arg2 = reinterpret_cast< wxValidator * >(argp2);
33643 {
33644 PyThreadState* __tstate = wxPyBeginAllowThreads();
33645 (arg1)->SetValidator((wxValidator const &)*arg2);
33646 wxPyEndAllowThreads(__tstate);
33647 if (PyErr_Occurred()) SWIG_fail;
33648 }
33649 resultobj = SWIG_Py_Void();
33650 return resultobj;
33651 fail:
33652 return NULL;
33653 }
33654
33655
33656 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33657 PyObject *resultobj = 0;
33658 wxWindow *arg1 = (wxWindow *) 0 ;
33659 wxValidator *result = 0 ;
33660 void *argp1 = 0 ;
33661 int res1 = 0 ;
33662 PyObject *swig_obj[1] ;
33663
33664 if (!args) SWIG_fail;
33665 swig_obj[0] = args;
33666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33667 if (!SWIG_IsOK(res1)) {
33668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33669 }
33670 arg1 = reinterpret_cast< wxWindow * >(argp1);
33671 {
33672 PyThreadState* __tstate = wxPyBeginAllowThreads();
33673 result = (wxValidator *)(arg1)->GetValidator();
33674 wxPyEndAllowThreads(__tstate);
33675 if (PyErr_Occurred()) SWIG_fail;
33676 }
33677 {
33678 resultobj = wxPyMake_wxObject(result, (bool)0);
33679 }
33680 return resultobj;
33681 fail:
33682 return NULL;
33683 }
33684
33685
33686 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33687 PyObject *resultobj = 0;
33688 wxWindow *arg1 = (wxWindow *) 0 ;
33689 bool result;
33690 void *argp1 = 0 ;
33691 int res1 = 0 ;
33692 PyObject *swig_obj[1] ;
33693
33694 if (!args) SWIG_fail;
33695 swig_obj[0] = args;
33696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33697 if (!SWIG_IsOK(res1)) {
33698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33699 }
33700 arg1 = reinterpret_cast< wxWindow * >(argp1);
33701 {
33702 PyThreadState* __tstate = wxPyBeginAllowThreads();
33703 result = (bool)(arg1)->Validate();
33704 wxPyEndAllowThreads(__tstate);
33705 if (PyErr_Occurred()) SWIG_fail;
33706 }
33707 {
33708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33709 }
33710 return resultobj;
33711 fail:
33712 return NULL;
33713 }
33714
33715
33716 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33717 PyObject *resultobj = 0;
33718 wxWindow *arg1 = (wxWindow *) 0 ;
33719 bool result;
33720 void *argp1 = 0 ;
33721 int res1 = 0 ;
33722 PyObject *swig_obj[1] ;
33723
33724 if (!args) SWIG_fail;
33725 swig_obj[0] = args;
33726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33727 if (!SWIG_IsOK(res1)) {
33728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33729 }
33730 arg1 = reinterpret_cast< wxWindow * >(argp1);
33731 {
33732 PyThreadState* __tstate = wxPyBeginAllowThreads();
33733 result = (bool)(arg1)->TransferDataToWindow();
33734 wxPyEndAllowThreads(__tstate);
33735 if (PyErr_Occurred()) SWIG_fail;
33736 }
33737 {
33738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33739 }
33740 return resultobj;
33741 fail:
33742 return NULL;
33743 }
33744
33745
33746 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33747 PyObject *resultobj = 0;
33748 wxWindow *arg1 = (wxWindow *) 0 ;
33749 bool result;
33750 void *argp1 = 0 ;
33751 int res1 = 0 ;
33752 PyObject *swig_obj[1] ;
33753
33754 if (!args) SWIG_fail;
33755 swig_obj[0] = args;
33756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33757 if (!SWIG_IsOK(res1)) {
33758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33759 }
33760 arg1 = reinterpret_cast< wxWindow * >(argp1);
33761 {
33762 PyThreadState* __tstate = wxPyBeginAllowThreads();
33763 result = (bool)(arg1)->TransferDataFromWindow();
33764 wxPyEndAllowThreads(__tstate);
33765 if (PyErr_Occurred()) SWIG_fail;
33766 }
33767 {
33768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33769 }
33770 return resultobj;
33771 fail:
33772 return NULL;
33773 }
33774
33775
33776 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33777 PyObject *resultobj = 0;
33778 wxWindow *arg1 = (wxWindow *) 0 ;
33779 void *argp1 = 0 ;
33780 int res1 = 0 ;
33781 PyObject *swig_obj[1] ;
33782
33783 if (!args) SWIG_fail;
33784 swig_obj[0] = args;
33785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33786 if (!SWIG_IsOK(res1)) {
33787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33788 }
33789 arg1 = reinterpret_cast< wxWindow * >(argp1);
33790 {
33791 PyThreadState* __tstate = wxPyBeginAllowThreads();
33792 (arg1)->InitDialog();
33793 wxPyEndAllowThreads(__tstate);
33794 if (PyErr_Occurred()) SWIG_fail;
33795 }
33796 resultobj = SWIG_Py_Void();
33797 return resultobj;
33798 fail:
33799 return NULL;
33800 }
33801
33802
33803 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33804 PyObject *resultobj = 0;
33805 wxWindow *arg1 = (wxWindow *) 0 ;
33806 wxAcceleratorTable *arg2 = 0 ;
33807 void *argp1 = 0 ;
33808 int res1 = 0 ;
33809 void *argp2 = 0 ;
33810 int res2 = 0 ;
33811 PyObject * obj0 = 0 ;
33812 PyObject * obj1 = 0 ;
33813 char * kwnames[] = {
33814 (char *) "self",(char *) "accel", NULL
33815 };
33816
33817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33819 if (!SWIG_IsOK(res1)) {
33820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33821 }
33822 arg1 = reinterpret_cast< wxWindow * >(argp1);
33823 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33824 if (!SWIG_IsOK(res2)) {
33825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33826 }
33827 if (!argp2) {
33828 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33829 }
33830 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33831 {
33832 PyThreadState* __tstate = wxPyBeginAllowThreads();
33833 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33834 wxPyEndAllowThreads(__tstate);
33835 if (PyErr_Occurred()) SWIG_fail;
33836 }
33837 resultobj = SWIG_Py_Void();
33838 return resultobj;
33839 fail:
33840 return NULL;
33841 }
33842
33843
33844 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33845 PyObject *resultobj = 0;
33846 wxWindow *arg1 = (wxWindow *) 0 ;
33847 wxAcceleratorTable *result = 0 ;
33848 void *argp1 = 0 ;
33849 int res1 = 0 ;
33850 PyObject *swig_obj[1] ;
33851
33852 if (!args) SWIG_fail;
33853 swig_obj[0] = args;
33854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33855 if (!SWIG_IsOK(res1)) {
33856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33857 }
33858 arg1 = reinterpret_cast< wxWindow * >(argp1);
33859 {
33860 PyThreadState* __tstate = wxPyBeginAllowThreads();
33861 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33862 wxPyEndAllowThreads(__tstate);
33863 if (PyErr_Occurred()) SWIG_fail;
33864 }
33865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33866 return resultobj;
33867 fail:
33868 return NULL;
33869 }
33870
33871
33872 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33873 PyObject *resultobj = 0;
33874 wxWindow *arg1 = (wxWindow *) 0 ;
33875 int arg2 ;
33876 int arg3 ;
33877 int arg4 ;
33878 bool result;
33879 void *argp1 = 0 ;
33880 int res1 = 0 ;
33881 int val2 ;
33882 int ecode2 = 0 ;
33883 int val3 ;
33884 int ecode3 = 0 ;
33885 int val4 ;
33886 int ecode4 = 0 ;
33887 PyObject * obj0 = 0 ;
33888 PyObject * obj1 = 0 ;
33889 PyObject * obj2 = 0 ;
33890 PyObject * obj3 = 0 ;
33891 char * kwnames[] = {
33892 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33893 };
33894
33895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33897 if (!SWIG_IsOK(res1)) {
33898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33899 }
33900 arg1 = reinterpret_cast< wxWindow * >(argp1);
33901 ecode2 = SWIG_AsVal_int(obj1, &val2);
33902 if (!SWIG_IsOK(ecode2)) {
33903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33904 }
33905 arg2 = static_cast< int >(val2);
33906 ecode3 = SWIG_AsVal_int(obj2, &val3);
33907 if (!SWIG_IsOK(ecode3)) {
33908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33909 }
33910 arg3 = static_cast< int >(val3);
33911 ecode4 = SWIG_AsVal_int(obj3, &val4);
33912 if (!SWIG_IsOK(ecode4)) {
33913 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33914 }
33915 arg4 = static_cast< int >(val4);
33916 {
33917 PyThreadState* __tstate = wxPyBeginAllowThreads();
33918 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33919 wxPyEndAllowThreads(__tstate);
33920 if (PyErr_Occurred()) SWIG_fail;
33921 }
33922 {
33923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33924 }
33925 return resultobj;
33926 fail:
33927 return NULL;
33928 }
33929
33930
33931 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33932 PyObject *resultobj = 0;
33933 wxWindow *arg1 = (wxWindow *) 0 ;
33934 int arg2 ;
33935 bool result;
33936 void *argp1 = 0 ;
33937 int res1 = 0 ;
33938 int val2 ;
33939 int ecode2 = 0 ;
33940 PyObject * obj0 = 0 ;
33941 PyObject * obj1 = 0 ;
33942 char * kwnames[] = {
33943 (char *) "self",(char *) "hotkeyId", NULL
33944 };
33945
33946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33948 if (!SWIG_IsOK(res1)) {
33949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33950 }
33951 arg1 = reinterpret_cast< wxWindow * >(argp1);
33952 ecode2 = SWIG_AsVal_int(obj1, &val2);
33953 if (!SWIG_IsOK(ecode2)) {
33954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33955 }
33956 arg2 = static_cast< int >(val2);
33957 {
33958 PyThreadState* __tstate = wxPyBeginAllowThreads();
33959 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33960 wxPyEndAllowThreads(__tstate);
33961 if (PyErr_Occurred()) SWIG_fail;
33962 }
33963 {
33964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33965 }
33966 return resultobj;
33967 fail:
33968 return NULL;
33969 }
33970
33971
33972 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33973 PyObject *resultobj = 0;
33974 wxWindow *arg1 = (wxWindow *) 0 ;
33975 wxPoint *arg2 = 0 ;
33976 wxPoint result;
33977 void *argp1 = 0 ;
33978 int res1 = 0 ;
33979 wxPoint temp2 ;
33980 PyObject * obj0 = 0 ;
33981 PyObject * obj1 = 0 ;
33982 char * kwnames[] = {
33983 (char *) "self",(char *) "pt", NULL
33984 };
33985
33986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33988 if (!SWIG_IsOK(res1)) {
33989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33990 }
33991 arg1 = reinterpret_cast< wxWindow * >(argp1);
33992 {
33993 arg2 = &temp2;
33994 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33995 }
33996 {
33997 PyThreadState* __tstate = wxPyBeginAllowThreads();
33998 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33999 wxPyEndAllowThreads(__tstate);
34000 if (PyErr_Occurred()) SWIG_fail;
34001 }
34002 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34003 return resultobj;
34004 fail:
34005 return NULL;
34006 }
34007
34008
34009 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34010 PyObject *resultobj = 0;
34011 wxWindow *arg1 = (wxWindow *) 0 ;
34012 wxSize *arg2 = 0 ;
34013 wxSize result;
34014 void *argp1 = 0 ;
34015 int res1 = 0 ;
34016 wxSize temp2 ;
34017 PyObject * obj0 = 0 ;
34018 PyObject * obj1 = 0 ;
34019 char * kwnames[] = {
34020 (char *) "self",(char *) "sz", NULL
34021 };
34022
34023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34025 if (!SWIG_IsOK(res1)) {
34026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34027 }
34028 arg1 = reinterpret_cast< wxWindow * >(argp1);
34029 {
34030 arg2 = &temp2;
34031 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34032 }
34033 {
34034 PyThreadState* __tstate = wxPyBeginAllowThreads();
34035 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34036 wxPyEndAllowThreads(__tstate);
34037 if (PyErr_Occurred()) SWIG_fail;
34038 }
34039 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34040 return resultobj;
34041 fail:
34042 return NULL;
34043 }
34044
34045
34046 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34047 PyObject *resultobj = 0;
34048 wxWindow *arg1 = (wxWindow *) 0 ;
34049 wxPoint *arg2 = 0 ;
34050 wxPoint result;
34051 void *argp1 = 0 ;
34052 int res1 = 0 ;
34053 wxPoint temp2 ;
34054 PyObject * obj0 = 0 ;
34055 PyObject * obj1 = 0 ;
34056 char * kwnames[] = {
34057 (char *) "self",(char *) "pt", NULL
34058 };
34059
34060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34062 if (!SWIG_IsOK(res1)) {
34063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34064 }
34065 arg1 = reinterpret_cast< wxWindow * >(argp1);
34066 {
34067 arg2 = &temp2;
34068 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34069 }
34070 {
34071 PyThreadState* __tstate = wxPyBeginAllowThreads();
34072 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34073 wxPyEndAllowThreads(__tstate);
34074 if (PyErr_Occurred()) SWIG_fail;
34075 }
34076 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34077 return resultobj;
34078 fail:
34079 return NULL;
34080 }
34081
34082
34083 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34084 PyObject *resultobj = 0;
34085 wxWindow *arg1 = (wxWindow *) 0 ;
34086 wxSize *arg2 = 0 ;
34087 wxSize result;
34088 void *argp1 = 0 ;
34089 int res1 = 0 ;
34090 wxSize temp2 ;
34091 PyObject * obj0 = 0 ;
34092 PyObject * obj1 = 0 ;
34093 char * kwnames[] = {
34094 (char *) "self",(char *) "sz", NULL
34095 };
34096
34097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34099 if (!SWIG_IsOK(res1)) {
34100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34101 }
34102 arg1 = reinterpret_cast< wxWindow * >(argp1);
34103 {
34104 arg2 = &temp2;
34105 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34106 }
34107 {
34108 PyThreadState* __tstate = wxPyBeginAllowThreads();
34109 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34110 wxPyEndAllowThreads(__tstate);
34111 if (PyErr_Occurred()) SWIG_fail;
34112 }
34113 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34114 return resultobj;
34115 fail:
34116 return NULL;
34117 }
34118
34119
34120 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34121 PyObject *resultobj = 0;
34122 wxWindow *arg1 = (wxWindow *) 0 ;
34123 wxPoint *arg2 = 0 ;
34124 wxPoint result;
34125 void *argp1 = 0 ;
34126 int res1 = 0 ;
34127 wxPoint temp2 ;
34128 PyObject * obj0 = 0 ;
34129 PyObject * obj1 = 0 ;
34130 char * kwnames[] = {
34131 (char *) "self",(char *) "pt", NULL
34132 };
34133
34134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34136 if (!SWIG_IsOK(res1)) {
34137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34138 }
34139 arg1 = reinterpret_cast< wxWindow * >(argp1);
34140 {
34141 arg2 = &temp2;
34142 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34143 }
34144 {
34145 PyThreadState* __tstate = wxPyBeginAllowThreads();
34146 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34147 wxPyEndAllowThreads(__tstate);
34148 if (PyErr_Occurred()) SWIG_fail;
34149 }
34150 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34151 return resultobj;
34152 fail:
34153 return NULL;
34154 }
34155
34156
34157 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34158 PyObject *resultobj = 0;
34159 wxWindow *arg1 = (wxWindow *) 0 ;
34160 wxSize *arg2 = 0 ;
34161 wxSize result;
34162 void *argp1 = 0 ;
34163 int res1 = 0 ;
34164 wxSize temp2 ;
34165 PyObject * obj0 = 0 ;
34166 PyObject * obj1 = 0 ;
34167 char * kwnames[] = {
34168 (char *) "self",(char *) "sz", NULL
34169 };
34170
34171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) 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_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34175 }
34176 arg1 = reinterpret_cast< wxWindow * >(argp1);
34177 {
34178 arg2 = &temp2;
34179 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34180 }
34181 {
34182 PyThreadState* __tstate = wxPyBeginAllowThreads();
34183 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34184 wxPyEndAllowThreads(__tstate);
34185 if (PyErr_Occurred()) SWIG_fail;
34186 }
34187 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34188 return resultobj;
34189 fail:
34190 return NULL;
34191 }
34192
34193
34194 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34195 PyObject *resultobj = 0;
34196 wxWindow *arg1 = (wxWindow *) 0 ;
34197 int arg2 ;
34198 int arg3 ;
34199 void *argp1 = 0 ;
34200 int res1 = 0 ;
34201 int val2 ;
34202 int ecode2 = 0 ;
34203 int val3 ;
34204 int ecode3 = 0 ;
34205 PyObject * obj0 = 0 ;
34206 PyObject * obj1 = 0 ;
34207 PyObject * obj2 = 0 ;
34208 char * kwnames[] = {
34209 (char *) "self",(char *) "x",(char *) "y", NULL
34210 };
34211
34212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34214 if (!SWIG_IsOK(res1)) {
34215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34216 }
34217 arg1 = reinterpret_cast< wxWindow * >(argp1);
34218 ecode2 = SWIG_AsVal_int(obj1, &val2);
34219 if (!SWIG_IsOK(ecode2)) {
34220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34221 }
34222 arg2 = static_cast< int >(val2);
34223 ecode3 = SWIG_AsVal_int(obj2, &val3);
34224 if (!SWIG_IsOK(ecode3)) {
34225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34226 }
34227 arg3 = static_cast< int >(val3);
34228 {
34229 PyThreadState* __tstate = wxPyBeginAllowThreads();
34230 (arg1)->WarpPointer(arg2,arg3);
34231 wxPyEndAllowThreads(__tstate);
34232 if (PyErr_Occurred()) SWIG_fail;
34233 }
34234 resultobj = SWIG_Py_Void();
34235 return resultobj;
34236 fail:
34237 return NULL;
34238 }
34239
34240
34241 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34242 PyObject *resultobj = 0;
34243 wxWindow *arg1 = (wxWindow *) 0 ;
34244 void *argp1 = 0 ;
34245 int res1 = 0 ;
34246 PyObject *swig_obj[1] ;
34247
34248 if (!args) SWIG_fail;
34249 swig_obj[0] = args;
34250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34251 if (!SWIG_IsOK(res1)) {
34252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34253 }
34254 arg1 = reinterpret_cast< wxWindow * >(argp1);
34255 {
34256 PyThreadState* __tstate = wxPyBeginAllowThreads();
34257 (arg1)->CaptureMouse();
34258 wxPyEndAllowThreads(__tstate);
34259 if (PyErr_Occurred()) SWIG_fail;
34260 }
34261 resultobj = SWIG_Py_Void();
34262 return resultobj;
34263 fail:
34264 return NULL;
34265 }
34266
34267
34268 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34269 PyObject *resultobj = 0;
34270 wxWindow *arg1 = (wxWindow *) 0 ;
34271 void *argp1 = 0 ;
34272 int res1 = 0 ;
34273 PyObject *swig_obj[1] ;
34274
34275 if (!args) SWIG_fail;
34276 swig_obj[0] = args;
34277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34278 if (!SWIG_IsOK(res1)) {
34279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34280 }
34281 arg1 = reinterpret_cast< wxWindow * >(argp1);
34282 {
34283 PyThreadState* __tstate = wxPyBeginAllowThreads();
34284 (arg1)->ReleaseMouse();
34285 wxPyEndAllowThreads(__tstate);
34286 if (PyErr_Occurred()) SWIG_fail;
34287 }
34288 resultobj = SWIG_Py_Void();
34289 return resultobj;
34290 fail:
34291 return NULL;
34292 }
34293
34294
34295 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34296 PyObject *resultobj = 0;
34297 wxWindow *result = 0 ;
34298
34299 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34300 {
34301 if (!wxPyCheckForApp()) SWIG_fail;
34302 PyThreadState* __tstate = wxPyBeginAllowThreads();
34303 result = (wxWindow *)wxWindow::GetCapture();
34304 wxPyEndAllowThreads(__tstate);
34305 if (PyErr_Occurred()) SWIG_fail;
34306 }
34307 {
34308 resultobj = wxPyMake_wxObject(result, 0);
34309 }
34310 return resultobj;
34311 fail:
34312 return NULL;
34313 }
34314
34315
34316 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34317 PyObject *resultobj = 0;
34318 wxWindow *arg1 = (wxWindow *) 0 ;
34319 bool result;
34320 void *argp1 = 0 ;
34321 int res1 = 0 ;
34322 PyObject *swig_obj[1] ;
34323
34324 if (!args) SWIG_fail;
34325 swig_obj[0] = args;
34326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34327 if (!SWIG_IsOK(res1)) {
34328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34329 }
34330 arg1 = reinterpret_cast< wxWindow * >(argp1);
34331 {
34332 PyThreadState* __tstate = wxPyBeginAllowThreads();
34333 result = (bool)((wxWindow const *)arg1)->HasCapture();
34334 wxPyEndAllowThreads(__tstate);
34335 if (PyErr_Occurred()) SWIG_fail;
34336 }
34337 {
34338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34339 }
34340 return resultobj;
34341 fail:
34342 return NULL;
34343 }
34344
34345
34346 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34347 PyObject *resultobj = 0;
34348 wxWindow *arg1 = (wxWindow *) 0 ;
34349 bool arg2 = (bool) true ;
34350 wxRect *arg3 = (wxRect *) NULL ;
34351 void *argp1 = 0 ;
34352 int res1 = 0 ;
34353 bool val2 ;
34354 int ecode2 = 0 ;
34355 void *argp3 = 0 ;
34356 int res3 = 0 ;
34357 PyObject * obj0 = 0 ;
34358 PyObject * obj1 = 0 ;
34359 PyObject * obj2 = 0 ;
34360 char * kwnames[] = {
34361 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34362 };
34363
34364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34366 if (!SWIG_IsOK(res1)) {
34367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34368 }
34369 arg1 = reinterpret_cast< wxWindow * >(argp1);
34370 if (obj1) {
34371 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34372 if (!SWIG_IsOK(ecode2)) {
34373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34374 }
34375 arg2 = static_cast< bool >(val2);
34376 }
34377 if (obj2) {
34378 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34379 if (!SWIG_IsOK(res3)) {
34380 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34381 }
34382 arg3 = reinterpret_cast< wxRect * >(argp3);
34383 }
34384 {
34385 PyThreadState* __tstate = wxPyBeginAllowThreads();
34386 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34387 wxPyEndAllowThreads(__tstate);
34388 if (PyErr_Occurred()) SWIG_fail;
34389 }
34390 resultobj = SWIG_Py_Void();
34391 return resultobj;
34392 fail:
34393 return NULL;
34394 }
34395
34396
34397 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34398 PyObject *resultobj = 0;
34399 wxWindow *arg1 = (wxWindow *) 0 ;
34400 wxRect *arg2 = 0 ;
34401 bool arg3 = (bool) true ;
34402 void *argp1 = 0 ;
34403 int res1 = 0 ;
34404 wxRect temp2 ;
34405 bool val3 ;
34406 int ecode3 = 0 ;
34407 PyObject * obj0 = 0 ;
34408 PyObject * obj1 = 0 ;
34409 PyObject * obj2 = 0 ;
34410 char * kwnames[] = {
34411 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34412 };
34413
34414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34416 if (!SWIG_IsOK(res1)) {
34417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34418 }
34419 arg1 = reinterpret_cast< wxWindow * >(argp1);
34420 {
34421 arg2 = &temp2;
34422 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34423 }
34424 if (obj2) {
34425 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34426 if (!SWIG_IsOK(ecode3)) {
34427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34428 }
34429 arg3 = static_cast< bool >(val3);
34430 }
34431 {
34432 PyThreadState* __tstate = wxPyBeginAllowThreads();
34433 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34434 wxPyEndAllowThreads(__tstate);
34435 if (PyErr_Occurred()) SWIG_fail;
34436 }
34437 resultobj = SWIG_Py_Void();
34438 return resultobj;
34439 fail:
34440 return NULL;
34441 }
34442
34443
34444 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34445 PyObject *resultobj = 0;
34446 wxWindow *arg1 = (wxWindow *) 0 ;
34447 void *argp1 = 0 ;
34448 int res1 = 0 ;
34449 PyObject *swig_obj[1] ;
34450
34451 if (!args) SWIG_fail;
34452 swig_obj[0] = args;
34453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34454 if (!SWIG_IsOK(res1)) {
34455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34456 }
34457 arg1 = reinterpret_cast< wxWindow * >(argp1);
34458 {
34459 PyThreadState* __tstate = wxPyBeginAllowThreads();
34460 (arg1)->Update();
34461 wxPyEndAllowThreads(__tstate);
34462 if (PyErr_Occurred()) SWIG_fail;
34463 }
34464 resultobj = SWIG_Py_Void();
34465 return resultobj;
34466 fail:
34467 return NULL;
34468 }
34469
34470
34471 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34472 PyObject *resultobj = 0;
34473 wxWindow *arg1 = (wxWindow *) 0 ;
34474 void *argp1 = 0 ;
34475 int res1 = 0 ;
34476 PyObject *swig_obj[1] ;
34477
34478 if (!args) SWIG_fail;
34479 swig_obj[0] = args;
34480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34481 if (!SWIG_IsOK(res1)) {
34482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34483 }
34484 arg1 = reinterpret_cast< wxWindow * >(argp1);
34485 {
34486 PyThreadState* __tstate = wxPyBeginAllowThreads();
34487 (arg1)->ClearBackground();
34488 wxPyEndAllowThreads(__tstate);
34489 if (PyErr_Occurred()) SWIG_fail;
34490 }
34491 resultobj = SWIG_Py_Void();
34492 return resultobj;
34493 fail:
34494 return NULL;
34495 }
34496
34497
34498 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34499 PyObject *resultobj = 0;
34500 wxWindow *arg1 = (wxWindow *) 0 ;
34501 void *argp1 = 0 ;
34502 int res1 = 0 ;
34503 PyObject *swig_obj[1] ;
34504
34505 if (!args) SWIG_fail;
34506 swig_obj[0] = args;
34507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34508 if (!SWIG_IsOK(res1)) {
34509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34510 }
34511 arg1 = reinterpret_cast< wxWindow * >(argp1);
34512 {
34513 PyThreadState* __tstate = wxPyBeginAllowThreads();
34514 (arg1)->Freeze();
34515 wxPyEndAllowThreads(__tstate);
34516 if (PyErr_Occurred()) SWIG_fail;
34517 }
34518 resultobj = SWIG_Py_Void();
34519 return resultobj;
34520 fail:
34521 return NULL;
34522 }
34523
34524
34525 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34526 PyObject *resultobj = 0;
34527 wxWindow *arg1 = (wxWindow *) 0 ;
34528 void *argp1 = 0 ;
34529 int res1 = 0 ;
34530 PyObject *swig_obj[1] ;
34531
34532 if (!args) SWIG_fail;
34533 swig_obj[0] = args;
34534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34535 if (!SWIG_IsOK(res1)) {
34536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34537 }
34538 arg1 = reinterpret_cast< wxWindow * >(argp1);
34539 {
34540 PyThreadState* __tstate = wxPyBeginAllowThreads();
34541 (arg1)->Thaw();
34542 wxPyEndAllowThreads(__tstate);
34543 if (PyErr_Occurred()) SWIG_fail;
34544 }
34545 resultobj = SWIG_Py_Void();
34546 return resultobj;
34547 fail:
34548 return NULL;
34549 }
34550
34551
34552 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34553 PyObject *resultobj = 0;
34554 wxWindow *arg1 = (wxWindow *) 0 ;
34555 wxDC *arg2 = 0 ;
34556 void *argp1 = 0 ;
34557 int res1 = 0 ;
34558 void *argp2 = 0 ;
34559 int res2 = 0 ;
34560 PyObject * obj0 = 0 ;
34561 PyObject * obj1 = 0 ;
34562 char * kwnames[] = {
34563 (char *) "self",(char *) "dc", NULL
34564 };
34565
34566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34568 if (!SWIG_IsOK(res1)) {
34569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34570 }
34571 arg1 = reinterpret_cast< wxWindow * >(argp1);
34572 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34573 if (!SWIG_IsOK(res2)) {
34574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34575 }
34576 if (!argp2) {
34577 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34578 }
34579 arg2 = reinterpret_cast< wxDC * >(argp2);
34580 {
34581 PyThreadState* __tstate = wxPyBeginAllowThreads();
34582 (arg1)->PrepareDC(*arg2);
34583 wxPyEndAllowThreads(__tstate);
34584 if (PyErr_Occurred()) SWIG_fail;
34585 }
34586 resultobj = SWIG_Py_Void();
34587 return resultobj;
34588 fail:
34589 return NULL;
34590 }
34591
34592
34593 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34594 PyObject *resultobj = 0;
34595 wxWindow *arg1 = (wxWindow *) 0 ;
34596 wxRegion *result = 0 ;
34597 void *argp1 = 0 ;
34598 int res1 = 0 ;
34599 PyObject *swig_obj[1] ;
34600
34601 if (!args) SWIG_fail;
34602 swig_obj[0] = args;
34603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34604 if (!SWIG_IsOK(res1)) {
34605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34606 }
34607 arg1 = reinterpret_cast< wxWindow * >(argp1);
34608 {
34609 PyThreadState* __tstate = wxPyBeginAllowThreads();
34610 {
34611 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34612 result = (wxRegion *) &_result_ref;
34613 }
34614 wxPyEndAllowThreads(__tstate);
34615 if (PyErr_Occurred()) SWIG_fail;
34616 }
34617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34618 return resultobj;
34619 fail:
34620 return NULL;
34621 }
34622
34623
34624 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34625 PyObject *resultobj = 0;
34626 wxWindow *arg1 = (wxWindow *) 0 ;
34627 wxRect result;
34628 void *argp1 = 0 ;
34629 int res1 = 0 ;
34630 PyObject *swig_obj[1] ;
34631
34632 if (!args) SWIG_fail;
34633 swig_obj[0] = args;
34634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34635 if (!SWIG_IsOK(res1)) {
34636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34637 }
34638 arg1 = reinterpret_cast< wxWindow * >(argp1);
34639 {
34640 PyThreadState* __tstate = wxPyBeginAllowThreads();
34641 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34642 wxPyEndAllowThreads(__tstate);
34643 if (PyErr_Occurred()) SWIG_fail;
34644 }
34645 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34646 return resultobj;
34647 fail:
34648 return NULL;
34649 }
34650
34651
34652 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34653 PyObject *resultobj = 0;
34654 wxWindow *arg1 = (wxWindow *) 0 ;
34655 int arg2 ;
34656 int arg3 ;
34657 int arg4 = (int) 1 ;
34658 int arg5 = (int) 1 ;
34659 bool result;
34660 void *argp1 = 0 ;
34661 int res1 = 0 ;
34662 int val2 ;
34663 int ecode2 = 0 ;
34664 int val3 ;
34665 int ecode3 = 0 ;
34666 int val4 ;
34667 int ecode4 = 0 ;
34668 int val5 ;
34669 int ecode5 = 0 ;
34670 PyObject * obj0 = 0 ;
34671 PyObject * obj1 = 0 ;
34672 PyObject * obj2 = 0 ;
34673 PyObject * obj3 = 0 ;
34674 PyObject * obj4 = 0 ;
34675 char * kwnames[] = {
34676 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34677 };
34678
34679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34681 if (!SWIG_IsOK(res1)) {
34682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34683 }
34684 arg1 = reinterpret_cast< wxWindow * >(argp1);
34685 ecode2 = SWIG_AsVal_int(obj1, &val2);
34686 if (!SWIG_IsOK(ecode2)) {
34687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34688 }
34689 arg2 = static_cast< int >(val2);
34690 ecode3 = SWIG_AsVal_int(obj2, &val3);
34691 if (!SWIG_IsOK(ecode3)) {
34692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34693 }
34694 arg3 = static_cast< int >(val3);
34695 if (obj3) {
34696 ecode4 = SWIG_AsVal_int(obj3, &val4);
34697 if (!SWIG_IsOK(ecode4)) {
34698 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34699 }
34700 arg4 = static_cast< int >(val4);
34701 }
34702 if (obj4) {
34703 ecode5 = SWIG_AsVal_int(obj4, &val5);
34704 if (!SWIG_IsOK(ecode5)) {
34705 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34706 }
34707 arg5 = static_cast< int >(val5);
34708 }
34709 {
34710 PyThreadState* __tstate = wxPyBeginAllowThreads();
34711 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34712 wxPyEndAllowThreads(__tstate);
34713 if (PyErr_Occurred()) SWIG_fail;
34714 }
34715 {
34716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34717 }
34718 return resultobj;
34719 fail:
34720 return NULL;
34721 }
34722
34723
34724 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34725 PyObject *resultobj = 0;
34726 wxWindow *arg1 = (wxWindow *) 0 ;
34727 wxPoint *arg2 = 0 ;
34728 bool result;
34729 void *argp1 = 0 ;
34730 int res1 = 0 ;
34731 wxPoint temp2 ;
34732 PyObject * obj0 = 0 ;
34733 PyObject * obj1 = 0 ;
34734 char * kwnames[] = {
34735 (char *) "self",(char *) "pt", NULL
34736 };
34737
34738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34740 if (!SWIG_IsOK(res1)) {
34741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34742 }
34743 arg1 = reinterpret_cast< wxWindow * >(argp1);
34744 {
34745 arg2 = &temp2;
34746 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34747 }
34748 {
34749 PyThreadState* __tstate = wxPyBeginAllowThreads();
34750 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34751 wxPyEndAllowThreads(__tstate);
34752 if (PyErr_Occurred()) SWIG_fail;
34753 }
34754 {
34755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34756 }
34757 return resultobj;
34758 fail:
34759 return NULL;
34760 }
34761
34762
34763 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34764 PyObject *resultobj = 0;
34765 wxWindow *arg1 = (wxWindow *) 0 ;
34766 wxRect *arg2 = 0 ;
34767 bool result;
34768 void *argp1 = 0 ;
34769 int res1 = 0 ;
34770 wxRect temp2 ;
34771 PyObject * obj0 = 0 ;
34772 PyObject * obj1 = 0 ;
34773 char * kwnames[] = {
34774 (char *) "self",(char *) "rect", NULL
34775 };
34776
34777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34779 if (!SWIG_IsOK(res1)) {
34780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34781 }
34782 arg1 = reinterpret_cast< wxWindow * >(argp1);
34783 {
34784 arg2 = &temp2;
34785 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34786 }
34787 {
34788 PyThreadState* __tstate = wxPyBeginAllowThreads();
34789 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34790 wxPyEndAllowThreads(__tstate);
34791 if (PyErr_Occurred()) SWIG_fail;
34792 }
34793 {
34794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34795 }
34796 return resultobj;
34797 fail:
34798 return NULL;
34799 }
34800
34801
34802 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34803 PyObject *resultobj = 0;
34804 wxWindow *arg1 = (wxWindow *) 0 ;
34805 SwigValueWrapper<wxVisualAttributes > result;
34806 void *argp1 = 0 ;
34807 int res1 = 0 ;
34808 PyObject *swig_obj[1] ;
34809
34810 if (!args) SWIG_fail;
34811 swig_obj[0] = args;
34812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34813 if (!SWIG_IsOK(res1)) {
34814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34815 }
34816 arg1 = reinterpret_cast< wxWindow * >(argp1);
34817 {
34818 PyThreadState* __tstate = wxPyBeginAllowThreads();
34819 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34820 wxPyEndAllowThreads(__tstate);
34821 if (PyErr_Occurred()) SWIG_fail;
34822 }
34823 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34824 return resultobj;
34825 fail:
34826 return NULL;
34827 }
34828
34829
34830 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34831 PyObject *resultobj = 0;
34832 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34833 SwigValueWrapper<wxVisualAttributes > result;
34834 int val1 ;
34835 int ecode1 = 0 ;
34836 PyObject * obj0 = 0 ;
34837 char * kwnames[] = {
34838 (char *) "variant", NULL
34839 };
34840
34841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34842 if (obj0) {
34843 ecode1 = SWIG_AsVal_int(obj0, &val1);
34844 if (!SWIG_IsOK(ecode1)) {
34845 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34846 }
34847 arg1 = static_cast< wxWindowVariant >(val1);
34848 }
34849 {
34850 if (!wxPyCheckForApp()) SWIG_fail;
34851 PyThreadState* __tstate = wxPyBeginAllowThreads();
34852 result = wxWindow::GetClassDefaultAttributes(arg1);
34853 wxPyEndAllowThreads(__tstate);
34854 if (PyErr_Occurred()) SWIG_fail;
34855 }
34856 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34857 return resultobj;
34858 fail:
34859 return NULL;
34860 }
34861
34862
34863 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34864 PyObject *resultobj = 0;
34865 wxWindow *arg1 = (wxWindow *) 0 ;
34866 wxColour *arg2 = 0 ;
34867 bool result;
34868 void *argp1 = 0 ;
34869 int res1 = 0 ;
34870 wxColour temp2 ;
34871 PyObject * obj0 = 0 ;
34872 PyObject * obj1 = 0 ;
34873 char * kwnames[] = {
34874 (char *) "self",(char *) "colour", NULL
34875 };
34876
34877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34879 if (!SWIG_IsOK(res1)) {
34880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34881 }
34882 arg1 = reinterpret_cast< wxWindow * >(argp1);
34883 {
34884 arg2 = &temp2;
34885 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34886 }
34887 {
34888 PyThreadState* __tstate = wxPyBeginAllowThreads();
34889 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34890 wxPyEndAllowThreads(__tstate);
34891 if (PyErr_Occurred()) SWIG_fail;
34892 }
34893 {
34894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34895 }
34896 return resultobj;
34897 fail:
34898 return NULL;
34899 }
34900
34901
34902 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34903 PyObject *resultobj = 0;
34904 wxWindow *arg1 = (wxWindow *) 0 ;
34905 wxColour *arg2 = 0 ;
34906 void *argp1 = 0 ;
34907 int res1 = 0 ;
34908 wxColour temp2 ;
34909 PyObject * obj0 = 0 ;
34910 PyObject * obj1 = 0 ;
34911 char * kwnames[] = {
34912 (char *) "self",(char *) "colour", NULL
34913 };
34914
34915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34917 if (!SWIG_IsOK(res1)) {
34918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34919 }
34920 arg1 = reinterpret_cast< wxWindow * >(argp1);
34921 {
34922 arg2 = &temp2;
34923 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34924 }
34925 {
34926 PyThreadState* __tstate = wxPyBeginAllowThreads();
34927 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34928 wxPyEndAllowThreads(__tstate);
34929 if (PyErr_Occurred()) SWIG_fail;
34930 }
34931 resultobj = SWIG_Py_Void();
34932 return resultobj;
34933 fail:
34934 return NULL;
34935 }
34936
34937
34938 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34939 PyObject *resultobj = 0;
34940 wxWindow *arg1 = (wxWindow *) 0 ;
34941 wxColour *arg2 = 0 ;
34942 bool result;
34943 void *argp1 = 0 ;
34944 int res1 = 0 ;
34945 wxColour temp2 ;
34946 PyObject * obj0 = 0 ;
34947 PyObject * obj1 = 0 ;
34948 char * kwnames[] = {
34949 (char *) "self",(char *) "colour", NULL
34950 };
34951
34952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34954 if (!SWIG_IsOK(res1)) {
34955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34956 }
34957 arg1 = reinterpret_cast< wxWindow * >(argp1);
34958 {
34959 arg2 = &temp2;
34960 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34961 }
34962 {
34963 PyThreadState* __tstate = wxPyBeginAllowThreads();
34964 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*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_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34978 PyObject *resultobj = 0;
34979 wxWindow *arg1 = (wxWindow *) 0 ;
34980 wxColour *arg2 = 0 ;
34981 void *argp1 = 0 ;
34982 int res1 = 0 ;
34983 wxColour temp2 ;
34984 PyObject * obj0 = 0 ;
34985 PyObject * obj1 = 0 ;
34986 char * kwnames[] = {
34987 (char *) "self",(char *) "colour", NULL
34988 };
34989
34990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34992 if (!SWIG_IsOK(res1)) {
34993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34994 }
34995 arg1 = reinterpret_cast< wxWindow * >(argp1);
34996 {
34997 arg2 = &temp2;
34998 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34999 }
35000 {
35001 PyThreadState* __tstate = wxPyBeginAllowThreads();
35002 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35003 wxPyEndAllowThreads(__tstate);
35004 if (PyErr_Occurred()) SWIG_fail;
35005 }
35006 resultobj = SWIG_Py_Void();
35007 return resultobj;
35008 fail:
35009 return NULL;
35010 }
35011
35012
35013 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35014 PyObject *resultobj = 0;
35015 wxWindow *arg1 = (wxWindow *) 0 ;
35016 wxColour result;
35017 void *argp1 = 0 ;
35018 int res1 = 0 ;
35019 PyObject *swig_obj[1] ;
35020
35021 if (!args) SWIG_fail;
35022 swig_obj[0] = args;
35023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35024 if (!SWIG_IsOK(res1)) {
35025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35026 }
35027 arg1 = reinterpret_cast< wxWindow * >(argp1);
35028 {
35029 PyThreadState* __tstate = wxPyBeginAllowThreads();
35030 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35031 wxPyEndAllowThreads(__tstate);
35032 if (PyErr_Occurred()) SWIG_fail;
35033 }
35034 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35035 return resultobj;
35036 fail:
35037 return NULL;
35038 }
35039
35040
35041 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35042 PyObject *resultobj = 0;
35043 wxWindow *arg1 = (wxWindow *) 0 ;
35044 wxColour result;
35045 void *argp1 = 0 ;
35046 int res1 = 0 ;
35047 PyObject *swig_obj[1] ;
35048
35049 if (!args) SWIG_fail;
35050 swig_obj[0] = args;
35051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35052 if (!SWIG_IsOK(res1)) {
35053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35054 }
35055 arg1 = reinterpret_cast< wxWindow * >(argp1);
35056 {
35057 PyThreadState* __tstate = wxPyBeginAllowThreads();
35058 result = ((wxWindow const *)arg1)->GetForegroundColour();
35059 wxPyEndAllowThreads(__tstate);
35060 if (PyErr_Occurred()) SWIG_fail;
35061 }
35062 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35063 return resultobj;
35064 fail:
35065 return NULL;
35066 }
35067
35068
35069 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35070 PyObject *resultobj = 0;
35071 wxWindow *arg1 = (wxWindow *) 0 ;
35072 bool result;
35073 void *argp1 = 0 ;
35074 int res1 = 0 ;
35075 PyObject *swig_obj[1] ;
35076
35077 if (!args) SWIG_fail;
35078 swig_obj[0] = args;
35079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35080 if (!SWIG_IsOK(res1)) {
35081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35082 }
35083 arg1 = reinterpret_cast< wxWindow * >(argp1);
35084 {
35085 PyThreadState* __tstate = wxPyBeginAllowThreads();
35086 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35087 wxPyEndAllowThreads(__tstate);
35088 if (PyErr_Occurred()) SWIG_fail;
35089 }
35090 {
35091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35092 }
35093 return resultobj;
35094 fail:
35095 return NULL;
35096 }
35097
35098
35099 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35100 PyObject *resultobj = 0;
35101 wxWindow *arg1 = (wxWindow *) 0 ;
35102 bool result;
35103 void *argp1 = 0 ;
35104 int res1 = 0 ;
35105 PyObject *swig_obj[1] ;
35106
35107 if (!args) SWIG_fail;
35108 swig_obj[0] = args;
35109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35110 if (!SWIG_IsOK(res1)) {
35111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35112 }
35113 arg1 = reinterpret_cast< wxWindow * >(argp1);
35114 {
35115 PyThreadState* __tstate = wxPyBeginAllowThreads();
35116 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35117 wxPyEndAllowThreads(__tstate);
35118 if (PyErr_Occurred()) SWIG_fail;
35119 }
35120 {
35121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35122 }
35123 return resultobj;
35124 fail:
35125 return NULL;
35126 }
35127
35128
35129 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35130 PyObject *resultobj = 0;
35131 wxWindow *arg1 = (wxWindow *) 0 ;
35132 wxBackgroundStyle arg2 ;
35133 bool result;
35134 void *argp1 = 0 ;
35135 int res1 = 0 ;
35136 int val2 ;
35137 int ecode2 = 0 ;
35138 PyObject * obj0 = 0 ;
35139 PyObject * obj1 = 0 ;
35140 char * kwnames[] = {
35141 (char *) "self",(char *) "style", NULL
35142 };
35143
35144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35146 if (!SWIG_IsOK(res1)) {
35147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35148 }
35149 arg1 = reinterpret_cast< wxWindow * >(argp1);
35150 ecode2 = SWIG_AsVal_int(obj1, &val2);
35151 if (!SWIG_IsOK(ecode2)) {
35152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35153 }
35154 arg2 = static_cast< wxBackgroundStyle >(val2);
35155 {
35156 PyThreadState* __tstate = wxPyBeginAllowThreads();
35157 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35158 wxPyEndAllowThreads(__tstate);
35159 if (PyErr_Occurred()) SWIG_fail;
35160 }
35161 {
35162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35163 }
35164 return resultobj;
35165 fail:
35166 return NULL;
35167 }
35168
35169
35170 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35171 PyObject *resultobj = 0;
35172 wxWindow *arg1 = (wxWindow *) 0 ;
35173 wxBackgroundStyle result;
35174 void *argp1 = 0 ;
35175 int res1 = 0 ;
35176 PyObject *swig_obj[1] ;
35177
35178 if (!args) SWIG_fail;
35179 swig_obj[0] = args;
35180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35181 if (!SWIG_IsOK(res1)) {
35182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35183 }
35184 arg1 = reinterpret_cast< wxWindow * >(argp1);
35185 {
35186 PyThreadState* __tstate = wxPyBeginAllowThreads();
35187 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35188 wxPyEndAllowThreads(__tstate);
35189 if (PyErr_Occurred()) SWIG_fail;
35190 }
35191 resultobj = SWIG_From_int(static_cast< int >(result));
35192 return resultobj;
35193 fail:
35194 return NULL;
35195 }
35196
35197
35198 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35199 PyObject *resultobj = 0;
35200 wxWindow *arg1 = (wxWindow *) 0 ;
35201 bool result;
35202 void *argp1 = 0 ;
35203 int res1 = 0 ;
35204 PyObject *swig_obj[1] ;
35205
35206 if (!args) SWIG_fail;
35207 swig_obj[0] = args;
35208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35209 if (!SWIG_IsOK(res1)) {
35210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35211 }
35212 arg1 = reinterpret_cast< wxWindow * >(argp1);
35213 {
35214 PyThreadState* __tstate = wxPyBeginAllowThreads();
35215 result = (bool)(arg1)->HasTransparentBackground();
35216 wxPyEndAllowThreads(__tstate);
35217 if (PyErr_Occurred()) SWIG_fail;
35218 }
35219 {
35220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35221 }
35222 return resultobj;
35223 fail:
35224 return NULL;
35225 }
35226
35227
35228 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35229 PyObject *resultobj = 0;
35230 wxWindow *arg1 = (wxWindow *) 0 ;
35231 wxCursor *arg2 = 0 ;
35232 bool result;
35233 void *argp1 = 0 ;
35234 int res1 = 0 ;
35235 void *argp2 = 0 ;
35236 int res2 = 0 ;
35237 PyObject * obj0 = 0 ;
35238 PyObject * obj1 = 0 ;
35239 char * kwnames[] = {
35240 (char *) "self",(char *) "cursor", NULL
35241 };
35242
35243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35245 if (!SWIG_IsOK(res1)) {
35246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35247 }
35248 arg1 = reinterpret_cast< wxWindow * >(argp1);
35249 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35250 if (!SWIG_IsOK(res2)) {
35251 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35252 }
35253 if (!argp2) {
35254 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35255 }
35256 arg2 = reinterpret_cast< wxCursor * >(argp2);
35257 {
35258 PyThreadState* __tstate = wxPyBeginAllowThreads();
35259 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35260 wxPyEndAllowThreads(__tstate);
35261 if (PyErr_Occurred()) SWIG_fail;
35262 }
35263 {
35264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35265 }
35266 return resultobj;
35267 fail:
35268 return NULL;
35269 }
35270
35271
35272 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35273 PyObject *resultobj = 0;
35274 wxWindow *arg1 = (wxWindow *) 0 ;
35275 wxCursor result;
35276 void *argp1 = 0 ;
35277 int res1 = 0 ;
35278 PyObject *swig_obj[1] ;
35279
35280 if (!args) SWIG_fail;
35281 swig_obj[0] = args;
35282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35283 if (!SWIG_IsOK(res1)) {
35284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35285 }
35286 arg1 = reinterpret_cast< wxWindow * >(argp1);
35287 {
35288 PyThreadState* __tstate = wxPyBeginAllowThreads();
35289 result = (arg1)->GetCursor();
35290 wxPyEndAllowThreads(__tstate);
35291 if (PyErr_Occurred()) SWIG_fail;
35292 }
35293 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35294 return resultobj;
35295 fail:
35296 return NULL;
35297 }
35298
35299
35300 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35301 PyObject *resultobj = 0;
35302 wxWindow *arg1 = (wxWindow *) 0 ;
35303 wxFont *arg2 = 0 ;
35304 bool result;
35305 void *argp1 = 0 ;
35306 int res1 = 0 ;
35307 void *argp2 = 0 ;
35308 int res2 = 0 ;
35309 PyObject * obj0 = 0 ;
35310 PyObject * obj1 = 0 ;
35311 char * kwnames[] = {
35312 (char *) "self",(char *) "font", NULL
35313 };
35314
35315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35317 if (!SWIG_IsOK(res1)) {
35318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35319 }
35320 arg1 = reinterpret_cast< wxWindow * >(argp1);
35321 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35322 if (!SWIG_IsOK(res2)) {
35323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35324 }
35325 if (!argp2) {
35326 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35327 }
35328 arg2 = reinterpret_cast< wxFont * >(argp2);
35329 {
35330 PyThreadState* __tstate = wxPyBeginAllowThreads();
35331 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35332 wxPyEndAllowThreads(__tstate);
35333 if (PyErr_Occurred()) SWIG_fail;
35334 }
35335 {
35336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35337 }
35338 return resultobj;
35339 fail:
35340 return NULL;
35341 }
35342
35343
35344 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35345 PyObject *resultobj = 0;
35346 wxWindow *arg1 = (wxWindow *) 0 ;
35347 wxFont *arg2 = 0 ;
35348 void *argp1 = 0 ;
35349 int res1 = 0 ;
35350 void *argp2 = 0 ;
35351 int res2 = 0 ;
35352 PyObject * obj0 = 0 ;
35353 PyObject * obj1 = 0 ;
35354 char * kwnames[] = {
35355 (char *) "self",(char *) "font", NULL
35356 };
35357
35358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35360 if (!SWIG_IsOK(res1)) {
35361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35362 }
35363 arg1 = reinterpret_cast< wxWindow * >(argp1);
35364 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35365 if (!SWIG_IsOK(res2)) {
35366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35367 }
35368 if (!argp2) {
35369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35370 }
35371 arg2 = reinterpret_cast< wxFont * >(argp2);
35372 {
35373 PyThreadState* __tstate = wxPyBeginAllowThreads();
35374 (arg1)->SetOwnFont((wxFont const &)*arg2);
35375 wxPyEndAllowThreads(__tstate);
35376 if (PyErr_Occurred()) SWIG_fail;
35377 }
35378 resultobj = SWIG_Py_Void();
35379 return resultobj;
35380 fail:
35381 return NULL;
35382 }
35383
35384
35385 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35386 PyObject *resultobj = 0;
35387 wxWindow *arg1 = (wxWindow *) 0 ;
35388 wxFont result;
35389 void *argp1 = 0 ;
35390 int res1 = 0 ;
35391 PyObject *swig_obj[1] ;
35392
35393 if (!args) SWIG_fail;
35394 swig_obj[0] = args;
35395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35396 if (!SWIG_IsOK(res1)) {
35397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35398 }
35399 arg1 = reinterpret_cast< wxWindow * >(argp1);
35400 {
35401 PyThreadState* __tstate = wxPyBeginAllowThreads();
35402 result = (arg1)->GetFont();
35403 wxPyEndAllowThreads(__tstate);
35404 if (PyErr_Occurred()) SWIG_fail;
35405 }
35406 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35407 return resultobj;
35408 fail:
35409 return NULL;
35410 }
35411
35412
35413 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35414 PyObject *resultobj = 0;
35415 wxWindow *arg1 = (wxWindow *) 0 ;
35416 wxCaret *arg2 = (wxCaret *) 0 ;
35417 void *argp1 = 0 ;
35418 int res1 = 0 ;
35419 int res2 = 0 ;
35420 PyObject * obj0 = 0 ;
35421 PyObject * obj1 = 0 ;
35422 char * kwnames[] = {
35423 (char *) "self",(char *) "caret", NULL
35424 };
35425
35426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35428 if (!SWIG_IsOK(res1)) {
35429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35430 }
35431 arg1 = reinterpret_cast< wxWindow * >(argp1);
35432 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35433 if (!SWIG_IsOK(res2)) {
35434 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35435 }
35436 {
35437 PyThreadState* __tstate = wxPyBeginAllowThreads();
35438 (arg1)->SetCaret(arg2);
35439 wxPyEndAllowThreads(__tstate);
35440 if (PyErr_Occurred()) SWIG_fail;
35441 }
35442 resultobj = SWIG_Py_Void();
35443 return resultobj;
35444 fail:
35445 return NULL;
35446 }
35447
35448
35449 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35450 PyObject *resultobj = 0;
35451 wxWindow *arg1 = (wxWindow *) 0 ;
35452 wxCaret *result = 0 ;
35453 void *argp1 = 0 ;
35454 int res1 = 0 ;
35455 PyObject *swig_obj[1] ;
35456
35457 if (!args) SWIG_fail;
35458 swig_obj[0] = args;
35459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35460 if (!SWIG_IsOK(res1)) {
35461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35462 }
35463 arg1 = reinterpret_cast< wxWindow * >(argp1);
35464 {
35465 PyThreadState* __tstate = wxPyBeginAllowThreads();
35466 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35467 wxPyEndAllowThreads(__tstate);
35468 if (PyErr_Occurred()) SWIG_fail;
35469 }
35470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35471 return resultobj;
35472 fail:
35473 return NULL;
35474 }
35475
35476
35477 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35478 PyObject *resultobj = 0;
35479 wxWindow *arg1 = (wxWindow *) 0 ;
35480 int result;
35481 void *argp1 = 0 ;
35482 int res1 = 0 ;
35483 PyObject *swig_obj[1] ;
35484
35485 if (!args) SWIG_fail;
35486 swig_obj[0] = args;
35487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35488 if (!SWIG_IsOK(res1)) {
35489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35490 }
35491 arg1 = reinterpret_cast< wxWindow * >(argp1);
35492 {
35493 PyThreadState* __tstate = wxPyBeginAllowThreads();
35494 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35495 wxPyEndAllowThreads(__tstate);
35496 if (PyErr_Occurred()) SWIG_fail;
35497 }
35498 resultobj = SWIG_From_int(static_cast< int >(result));
35499 return resultobj;
35500 fail:
35501 return NULL;
35502 }
35503
35504
35505 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35506 PyObject *resultobj = 0;
35507 wxWindow *arg1 = (wxWindow *) 0 ;
35508 int result;
35509 void *argp1 = 0 ;
35510 int res1 = 0 ;
35511 PyObject *swig_obj[1] ;
35512
35513 if (!args) SWIG_fail;
35514 swig_obj[0] = args;
35515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35516 if (!SWIG_IsOK(res1)) {
35517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35518 }
35519 arg1 = reinterpret_cast< wxWindow * >(argp1);
35520 {
35521 PyThreadState* __tstate = wxPyBeginAllowThreads();
35522 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35523 wxPyEndAllowThreads(__tstate);
35524 if (PyErr_Occurred()) SWIG_fail;
35525 }
35526 resultobj = SWIG_From_int(static_cast< int >(result));
35527 return resultobj;
35528 fail:
35529 return NULL;
35530 }
35531
35532
35533 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35534 PyObject *resultobj = 0;
35535 wxWindow *arg1 = (wxWindow *) 0 ;
35536 wxString *arg2 = 0 ;
35537 int *arg3 = (int *) 0 ;
35538 int *arg4 = (int *) 0 ;
35539 void *argp1 = 0 ;
35540 int res1 = 0 ;
35541 bool temp2 = false ;
35542 int temp3 ;
35543 int res3 = SWIG_TMPOBJ ;
35544 int temp4 ;
35545 int res4 = SWIG_TMPOBJ ;
35546 PyObject * obj0 = 0 ;
35547 PyObject * obj1 = 0 ;
35548 char * kwnames[] = {
35549 (char *) "self",(char *) "string", NULL
35550 };
35551
35552 arg3 = &temp3;
35553 arg4 = &temp4;
35554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35556 if (!SWIG_IsOK(res1)) {
35557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35558 }
35559 arg1 = reinterpret_cast< wxWindow * >(argp1);
35560 {
35561 arg2 = wxString_in_helper(obj1);
35562 if (arg2 == NULL) SWIG_fail;
35563 temp2 = true;
35564 }
35565 {
35566 PyThreadState* __tstate = wxPyBeginAllowThreads();
35567 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35568 wxPyEndAllowThreads(__tstate);
35569 if (PyErr_Occurred()) SWIG_fail;
35570 }
35571 resultobj = SWIG_Py_Void();
35572 if (SWIG_IsTmpObj(res3)) {
35573 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35574 } else {
35575 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35576 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35577 }
35578 if (SWIG_IsTmpObj(res4)) {
35579 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35580 } else {
35581 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35582 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35583 }
35584 {
35585 if (temp2)
35586 delete arg2;
35587 }
35588 return resultobj;
35589 fail:
35590 {
35591 if (temp2)
35592 delete arg2;
35593 }
35594 return NULL;
35595 }
35596
35597
35598 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35599 PyObject *resultobj = 0;
35600 wxWindow *arg1 = (wxWindow *) 0 ;
35601 wxString *arg2 = 0 ;
35602 int *arg3 = (int *) 0 ;
35603 int *arg4 = (int *) 0 ;
35604 int *arg5 = (int *) 0 ;
35605 int *arg6 = (int *) 0 ;
35606 wxFont *arg7 = (wxFont *) NULL ;
35607 void *argp1 = 0 ;
35608 int res1 = 0 ;
35609 bool temp2 = false ;
35610 int temp3 ;
35611 int res3 = SWIG_TMPOBJ ;
35612 int temp4 ;
35613 int res4 = SWIG_TMPOBJ ;
35614 int temp5 ;
35615 int res5 = SWIG_TMPOBJ ;
35616 int temp6 ;
35617 int res6 = SWIG_TMPOBJ ;
35618 void *argp7 = 0 ;
35619 int res7 = 0 ;
35620 PyObject * obj0 = 0 ;
35621 PyObject * obj1 = 0 ;
35622 PyObject * obj2 = 0 ;
35623 char * kwnames[] = {
35624 (char *) "self",(char *) "string",(char *) "font", NULL
35625 };
35626
35627 arg3 = &temp3;
35628 arg4 = &temp4;
35629 arg5 = &temp5;
35630 arg6 = &temp6;
35631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35633 if (!SWIG_IsOK(res1)) {
35634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35635 }
35636 arg1 = reinterpret_cast< wxWindow * >(argp1);
35637 {
35638 arg2 = wxString_in_helper(obj1);
35639 if (arg2 == NULL) SWIG_fail;
35640 temp2 = true;
35641 }
35642 if (obj2) {
35643 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35644 if (!SWIG_IsOK(res7)) {
35645 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35646 }
35647 arg7 = reinterpret_cast< wxFont * >(argp7);
35648 }
35649 {
35650 PyThreadState* __tstate = wxPyBeginAllowThreads();
35651 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35652 wxPyEndAllowThreads(__tstate);
35653 if (PyErr_Occurred()) SWIG_fail;
35654 }
35655 resultobj = SWIG_Py_Void();
35656 if (SWIG_IsTmpObj(res3)) {
35657 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35658 } else {
35659 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35660 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35661 }
35662 if (SWIG_IsTmpObj(res4)) {
35663 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35664 } else {
35665 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35666 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35667 }
35668 if (SWIG_IsTmpObj(res5)) {
35669 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35670 } else {
35671 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35672 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35673 }
35674 if (SWIG_IsTmpObj(res6)) {
35675 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35676 } else {
35677 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35678 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35679 }
35680 {
35681 if (temp2)
35682 delete arg2;
35683 }
35684 return resultobj;
35685 fail:
35686 {
35687 if (temp2)
35688 delete arg2;
35689 }
35690 return NULL;
35691 }
35692
35693
35694 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35695 PyObject *resultobj = 0;
35696 wxWindow *arg1 = (wxWindow *) 0 ;
35697 int *arg2 = (int *) 0 ;
35698 int *arg3 = (int *) 0 ;
35699 void *argp1 = 0 ;
35700 int res1 = 0 ;
35701 int temp2 ;
35702 int res2 = 0 ;
35703 int temp3 ;
35704 int res3 = 0 ;
35705 PyObject * obj0 = 0 ;
35706 PyObject * obj1 = 0 ;
35707 PyObject * obj2 = 0 ;
35708 char * kwnames[] = {
35709 (char *) "self",(char *) "x",(char *) "y", NULL
35710 };
35711
35712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35714 if (!SWIG_IsOK(res1)) {
35715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35716 }
35717 arg1 = reinterpret_cast< wxWindow * >(argp1);
35718 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35719 int val;
35720 int ecode = SWIG_AsVal_int(obj1, &val);
35721 if (!SWIG_IsOK(ecode)) {
35722 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35723 }
35724 temp2 = static_cast< int >(val);
35725 arg2 = &temp2;
35726 res2 = SWIG_AddTmpMask(ecode);
35727 }
35728 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35729 int val;
35730 int ecode = SWIG_AsVal_int(obj2, &val);
35731 if (!SWIG_IsOK(ecode)) {
35732 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35733 }
35734 temp3 = static_cast< int >(val);
35735 arg3 = &temp3;
35736 res3 = SWIG_AddTmpMask(ecode);
35737 }
35738 {
35739 PyThreadState* __tstate = wxPyBeginAllowThreads();
35740 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35741 wxPyEndAllowThreads(__tstate);
35742 if (PyErr_Occurred()) SWIG_fail;
35743 }
35744 resultobj = SWIG_Py_Void();
35745 if (SWIG_IsTmpObj(res2)) {
35746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35747 } else {
35748 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35750 }
35751 if (SWIG_IsTmpObj(res3)) {
35752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35753 } else {
35754 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35755 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35756 }
35757 return resultobj;
35758 fail:
35759 return NULL;
35760 }
35761
35762
35763 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35764 PyObject *resultobj = 0;
35765 wxWindow *arg1 = (wxWindow *) 0 ;
35766 int *arg2 = (int *) 0 ;
35767 int *arg3 = (int *) 0 ;
35768 void *argp1 = 0 ;
35769 int res1 = 0 ;
35770 int temp2 ;
35771 int res2 = 0 ;
35772 int temp3 ;
35773 int res3 = 0 ;
35774 PyObject * obj0 = 0 ;
35775 PyObject * obj1 = 0 ;
35776 PyObject * obj2 = 0 ;
35777 char * kwnames[] = {
35778 (char *) "self",(char *) "x",(char *) "y", NULL
35779 };
35780
35781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35783 if (!SWIG_IsOK(res1)) {
35784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35785 }
35786 arg1 = reinterpret_cast< wxWindow * >(argp1);
35787 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35788 int val;
35789 int ecode = SWIG_AsVal_int(obj1, &val);
35790 if (!SWIG_IsOK(ecode)) {
35791 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35792 }
35793 temp2 = static_cast< int >(val);
35794 arg2 = &temp2;
35795 res2 = SWIG_AddTmpMask(ecode);
35796 }
35797 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35798 int val;
35799 int ecode = SWIG_AsVal_int(obj2, &val);
35800 if (!SWIG_IsOK(ecode)) {
35801 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35802 }
35803 temp3 = static_cast< int >(val);
35804 arg3 = &temp3;
35805 res3 = SWIG_AddTmpMask(ecode);
35806 }
35807 {
35808 PyThreadState* __tstate = wxPyBeginAllowThreads();
35809 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35810 wxPyEndAllowThreads(__tstate);
35811 if (PyErr_Occurred()) SWIG_fail;
35812 }
35813 resultobj = SWIG_Py_Void();
35814 if (SWIG_IsTmpObj(res2)) {
35815 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35816 } else {
35817 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35818 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35819 }
35820 if (SWIG_IsTmpObj(res3)) {
35821 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35822 } else {
35823 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35825 }
35826 return resultobj;
35827 fail:
35828 return NULL;
35829 }
35830
35831
35832 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35833 PyObject *resultobj = 0;
35834 wxWindow *arg1 = (wxWindow *) 0 ;
35835 wxPoint *arg2 = 0 ;
35836 wxPoint result;
35837 void *argp1 = 0 ;
35838 int res1 = 0 ;
35839 wxPoint temp2 ;
35840 PyObject * obj0 = 0 ;
35841 PyObject * obj1 = 0 ;
35842 char * kwnames[] = {
35843 (char *) "self",(char *) "pt", NULL
35844 };
35845
35846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35848 if (!SWIG_IsOK(res1)) {
35849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35850 }
35851 arg1 = reinterpret_cast< wxWindow * >(argp1);
35852 {
35853 arg2 = &temp2;
35854 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35855 }
35856 {
35857 PyThreadState* __tstate = wxPyBeginAllowThreads();
35858 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35859 wxPyEndAllowThreads(__tstate);
35860 if (PyErr_Occurred()) SWIG_fail;
35861 }
35862 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35863 return resultobj;
35864 fail:
35865 return NULL;
35866 }
35867
35868
35869 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35870 PyObject *resultobj = 0;
35871 wxWindow *arg1 = (wxWindow *) 0 ;
35872 wxPoint *arg2 = 0 ;
35873 wxPoint result;
35874 void *argp1 = 0 ;
35875 int res1 = 0 ;
35876 wxPoint temp2 ;
35877 PyObject * obj0 = 0 ;
35878 PyObject * obj1 = 0 ;
35879 char * kwnames[] = {
35880 (char *) "self",(char *) "pt", NULL
35881 };
35882
35883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35885 if (!SWIG_IsOK(res1)) {
35886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35887 }
35888 arg1 = reinterpret_cast< wxWindow * >(argp1);
35889 {
35890 arg2 = &temp2;
35891 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35892 }
35893 {
35894 PyThreadState* __tstate = wxPyBeginAllowThreads();
35895 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35896 wxPyEndAllowThreads(__tstate);
35897 if (PyErr_Occurred()) SWIG_fail;
35898 }
35899 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35900 return resultobj;
35901 fail:
35902 return NULL;
35903 }
35904
35905
35906 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35907 PyObject *resultobj = 0;
35908 wxWindow *arg1 = (wxWindow *) 0 ;
35909 int arg2 ;
35910 int arg3 ;
35911 wxHitTest result;
35912 void *argp1 = 0 ;
35913 int res1 = 0 ;
35914 int val2 ;
35915 int ecode2 = 0 ;
35916 int val3 ;
35917 int ecode3 = 0 ;
35918 PyObject * obj0 = 0 ;
35919 PyObject * obj1 = 0 ;
35920 PyObject * obj2 = 0 ;
35921 char * kwnames[] = {
35922 (char *) "self",(char *) "x",(char *) "y", NULL
35923 };
35924
35925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35927 if (!SWIG_IsOK(res1)) {
35928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35929 }
35930 arg1 = reinterpret_cast< wxWindow * >(argp1);
35931 ecode2 = SWIG_AsVal_int(obj1, &val2);
35932 if (!SWIG_IsOK(ecode2)) {
35933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35934 }
35935 arg2 = static_cast< int >(val2);
35936 ecode3 = SWIG_AsVal_int(obj2, &val3);
35937 if (!SWIG_IsOK(ecode3)) {
35938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35939 }
35940 arg3 = static_cast< int >(val3);
35941 {
35942 PyThreadState* __tstate = wxPyBeginAllowThreads();
35943 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35944 wxPyEndAllowThreads(__tstate);
35945 if (PyErr_Occurred()) SWIG_fail;
35946 }
35947 resultobj = SWIG_From_int(static_cast< int >(result));
35948 return resultobj;
35949 fail:
35950 return NULL;
35951 }
35952
35953
35954 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35955 PyObject *resultobj = 0;
35956 wxWindow *arg1 = (wxWindow *) 0 ;
35957 wxPoint *arg2 = 0 ;
35958 wxHitTest result;
35959 void *argp1 = 0 ;
35960 int res1 = 0 ;
35961 wxPoint temp2 ;
35962 PyObject * obj0 = 0 ;
35963 PyObject * obj1 = 0 ;
35964 char * kwnames[] = {
35965 (char *) "self",(char *) "pt", NULL
35966 };
35967
35968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35970 if (!SWIG_IsOK(res1)) {
35971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35972 }
35973 arg1 = reinterpret_cast< wxWindow * >(argp1);
35974 {
35975 arg2 = &temp2;
35976 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35977 }
35978 {
35979 PyThreadState* __tstate = wxPyBeginAllowThreads();
35980 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35981 wxPyEndAllowThreads(__tstate);
35982 if (PyErr_Occurred()) SWIG_fail;
35983 }
35984 resultobj = SWIG_From_int(static_cast< int >(result));
35985 return resultobj;
35986 fail:
35987 return NULL;
35988 }
35989
35990
35991 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35992 PyObject *resultobj = 0;
35993 wxWindow *arg1 = (wxWindow *) 0 ;
35994 long arg2 ;
35995 wxBorder result;
35996 void *argp1 = 0 ;
35997 int res1 = 0 ;
35998 long val2 ;
35999 int ecode2 = 0 ;
36000
36001 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36003 if (!SWIG_IsOK(res1)) {
36004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36005 }
36006 arg1 = reinterpret_cast< wxWindow * >(argp1);
36007 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36008 if (!SWIG_IsOK(ecode2)) {
36009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36010 }
36011 arg2 = static_cast< long >(val2);
36012 {
36013 PyThreadState* __tstate = wxPyBeginAllowThreads();
36014 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36015 wxPyEndAllowThreads(__tstate);
36016 if (PyErr_Occurred()) SWIG_fail;
36017 }
36018 resultobj = SWIG_From_int(static_cast< int >(result));
36019 return resultobj;
36020 fail:
36021 return NULL;
36022 }
36023
36024
36025 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36026 PyObject *resultobj = 0;
36027 wxWindow *arg1 = (wxWindow *) 0 ;
36028 wxBorder result;
36029 void *argp1 = 0 ;
36030 int res1 = 0 ;
36031
36032 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36034 if (!SWIG_IsOK(res1)) {
36035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36036 }
36037 arg1 = reinterpret_cast< wxWindow * >(argp1);
36038 {
36039 PyThreadState* __tstate = wxPyBeginAllowThreads();
36040 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36041 wxPyEndAllowThreads(__tstate);
36042 if (PyErr_Occurred()) SWIG_fail;
36043 }
36044 resultobj = SWIG_From_int(static_cast< int >(result));
36045 return resultobj;
36046 fail:
36047 return NULL;
36048 }
36049
36050
36051 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36052 int argc;
36053 PyObject *argv[3];
36054
36055 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36056 --argc;
36057 if (argc == 1) {
36058 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36059 }
36060 if (argc == 2) {
36061 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36062 }
36063
36064 fail:
36065 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36066 return NULL;
36067 }
36068
36069
36070 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36071 PyObject *resultobj = 0;
36072 wxWindow *arg1 = (wxWindow *) 0 ;
36073 long arg2 = (long) wxUPDATE_UI_NONE ;
36074 void *argp1 = 0 ;
36075 int res1 = 0 ;
36076 long val2 ;
36077 int ecode2 = 0 ;
36078 PyObject * obj0 = 0 ;
36079 PyObject * obj1 = 0 ;
36080 char * kwnames[] = {
36081 (char *) "self",(char *) "flags", NULL
36082 };
36083
36084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36086 if (!SWIG_IsOK(res1)) {
36087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36088 }
36089 arg1 = reinterpret_cast< wxWindow * >(argp1);
36090 if (obj1) {
36091 ecode2 = SWIG_AsVal_long(obj1, &val2);
36092 if (!SWIG_IsOK(ecode2)) {
36093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36094 }
36095 arg2 = static_cast< long >(val2);
36096 }
36097 {
36098 PyThreadState* __tstate = wxPyBeginAllowThreads();
36099 (arg1)->UpdateWindowUI(arg2);
36100 wxPyEndAllowThreads(__tstate);
36101 if (PyErr_Occurred()) SWIG_fail;
36102 }
36103 resultobj = SWIG_Py_Void();
36104 return resultobj;
36105 fail:
36106 return NULL;
36107 }
36108
36109
36110 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36111 PyObject *resultobj = 0;
36112 wxWindow *arg1 = (wxWindow *) 0 ;
36113 wxMenu *arg2 = (wxMenu *) 0 ;
36114 int arg3 = (int) -1 ;
36115 int arg4 = (int) -1 ;
36116 bool result;
36117 void *argp1 = 0 ;
36118 int res1 = 0 ;
36119 void *argp2 = 0 ;
36120 int res2 = 0 ;
36121 int val3 ;
36122 int ecode3 = 0 ;
36123 int val4 ;
36124 int ecode4 = 0 ;
36125 PyObject * obj0 = 0 ;
36126 PyObject * obj1 = 0 ;
36127 PyObject * obj2 = 0 ;
36128 PyObject * obj3 = 0 ;
36129 char * kwnames[] = {
36130 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36131 };
36132
36133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36135 if (!SWIG_IsOK(res1)) {
36136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36137 }
36138 arg1 = reinterpret_cast< wxWindow * >(argp1);
36139 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36140 if (!SWIG_IsOK(res2)) {
36141 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36142 }
36143 arg2 = reinterpret_cast< wxMenu * >(argp2);
36144 if (obj2) {
36145 ecode3 = SWIG_AsVal_int(obj2, &val3);
36146 if (!SWIG_IsOK(ecode3)) {
36147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36148 }
36149 arg3 = static_cast< int >(val3);
36150 }
36151 if (obj3) {
36152 ecode4 = SWIG_AsVal_int(obj3, &val4);
36153 if (!SWIG_IsOK(ecode4)) {
36154 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36155 }
36156 arg4 = static_cast< int >(val4);
36157 }
36158 {
36159 PyThreadState* __tstate = wxPyBeginAllowThreads();
36160 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36161 wxPyEndAllowThreads(__tstate);
36162 if (PyErr_Occurred()) SWIG_fail;
36163 }
36164 {
36165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36166 }
36167 return resultobj;
36168 fail:
36169 return NULL;
36170 }
36171
36172
36173 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36174 PyObject *resultobj = 0;
36175 wxWindow *arg1 = (wxWindow *) 0 ;
36176 wxMenu *arg2 = (wxMenu *) 0 ;
36177 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36178 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36179 bool result;
36180 void *argp1 = 0 ;
36181 int res1 = 0 ;
36182 void *argp2 = 0 ;
36183 int res2 = 0 ;
36184 wxPoint temp3 ;
36185 PyObject * obj0 = 0 ;
36186 PyObject * obj1 = 0 ;
36187 PyObject * obj2 = 0 ;
36188 char * kwnames[] = {
36189 (char *) "self",(char *) "menu",(char *) "pos", NULL
36190 };
36191
36192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36194 if (!SWIG_IsOK(res1)) {
36195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36196 }
36197 arg1 = reinterpret_cast< wxWindow * >(argp1);
36198 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36199 if (!SWIG_IsOK(res2)) {
36200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36201 }
36202 arg2 = reinterpret_cast< wxMenu * >(argp2);
36203 if (obj2) {
36204 {
36205 arg3 = &temp3;
36206 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36207 }
36208 }
36209 {
36210 PyThreadState* __tstate = wxPyBeginAllowThreads();
36211 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36212 wxPyEndAllowThreads(__tstate);
36213 if (PyErr_Occurred()) SWIG_fail;
36214 }
36215 {
36216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36217 }
36218 return resultobj;
36219 fail:
36220 return NULL;
36221 }
36222
36223
36224 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36225 PyObject *resultobj = 0;
36226 wxWindow *arg1 = (wxWindow *) 0 ;
36227 long result;
36228 void *argp1 = 0 ;
36229 int res1 = 0 ;
36230 PyObject *swig_obj[1] ;
36231
36232 if (!args) SWIG_fail;
36233 swig_obj[0] = args;
36234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36235 if (!SWIG_IsOK(res1)) {
36236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36237 }
36238 arg1 = reinterpret_cast< wxWindow * >(argp1);
36239 {
36240 PyThreadState* __tstate = wxPyBeginAllowThreads();
36241 result = (long)wxWindow_GetHandle(arg1);
36242 wxPyEndAllowThreads(__tstate);
36243 if (PyErr_Occurred()) SWIG_fail;
36244 }
36245 resultobj = SWIG_From_long(static_cast< long >(result));
36246 return resultobj;
36247 fail:
36248 return NULL;
36249 }
36250
36251
36252 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36253 PyObject *resultobj = 0;
36254 wxWindow *arg1 = (wxWindow *) 0 ;
36255 long arg2 ;
36256 void *argp1 = 0 ;
36257 int res1 = 0 ;
36258 long val2 ;
36259 int ecode2 = 0 ;
36260 PyObject * obj0 = 0 ;
36261 PyObject * obj1 = 0 ;
36262 char * kwnames[] = {
36263 (char *) "self",(char *) "handle", NULL
36264 };
36265
36266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36268 if (!SWIG_IsOK(res1)) {
36269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36270 }
36271 arg1 = reinterpret_cast< wxWindow * >(argp1);
36272 ecode2 = SWIG_AsVal_long(obj1, &val2);
36273 if (!SWIG_IsOK(ecode2)) {
36274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36275 }
36276 arg2 = static_cast< long >(val2);
36277 {
36278 PyThreadState* __tstate = wxPyBeginAllowThreads();
36279 wxWindow_AssociateHandle(arg1,arg2);
36280 wxPyEndAllowThreads(__tstate);
36281 if (PyErr_Occurred()) SWIG_fail;
36282 }
36283 resultobj = SWIG_Py_Void();
36284 return resultobj;
36285 fail:
36286 return NULL;
36287 }
36288
36289
36290 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36291 PyObject *resultobj = 0;
36292 wxWindow *arg1 = (wxWindow *) 0 ;
36293 void *argp1 = 0 ;
36294 int res1 = 0 ;
36295 PyObject *swig_obj[1] ;
36296
36297 if (!args) SWIG_fail;
36298 swig_obj[0] = args;
36299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36300 if (!SWIG_IsOK(res1)) {
36301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36302 }
36303 arg1 = reinterpret_cast< wxWindow * >(argp1);
36304 {
36305 PyThreadState* __tstate = wxPyBeginAllowThreads();
36306 (arg1)->DissociateHandle();
36307 wxPyEndAllowThreads(__tstate);
36308 if (PyErr_Occurred()) SWIG_fail;
36309 }
36310 resultobj = SWIG_Py_Void();
36311 return resultobj;
36312 fail:
36313 return NULL;
36314 }
36315
36316
36317 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36318 PyObject *resultobj = 0;
36319 wxWindow *arg1 = (wxWindow *) 0 ;
36320 int arg2 ;
36321 bool result;
36322 void *argp1 = 0 ;
36323 int res1 = 0 ;
36324 int val2 ;
36325 int ecode2 = 0 ;
36326 PyObject * obj0 = 0 ;
36327 PyObject * obj1 = 0 ;
36328 char * kwnames[] = {
36329 (char *) "self",(char *) "orient", NULL
36330 };
36331
36332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36334 if (!SWIG_IsOK(res1)) {
36335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36336 }
36337 arg1 = reinterpret_cast< wxWindow * >(argp1);
36338 ecode2 = SWIG_AsVal_int(obj1, &val2);
36339 if (!SWIG_IsOK(ecode2)) {
36340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36341 }
36342 arg2 = static_cast< int >(val2);
36343 {
36344 PyThreadState* __tstate = wxPyBeginAllowThreads();
36345 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36346 wxPyEndAllowThreads(__tstate);
36347 if (PyErr_Occurred()) SWIG_fail;
36348 }
36349 {
36350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36351 }
36352 return resultobj;
36353 fail:
36354 return NULL;
36355 }
36356
36357
36358 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36359 PyObject *resultobj = 0;
36360 wxWindow *arg1 = (wxWindow *) 0 ;
36361 int arg2 ;
36362 int arg3 ;
36363 int arg4 ;
36364 int arg5 ;
36365 bool arg6 = (bool) true ;
36366 void *argp1 = 0 ;
36367 int res1 = 0 ;
36368 int val2 ;
36369 int ecode2 = 0 ;
36370 int val3 ;
36371 int ecode3 = 0 ;
36372 int val4 ;
36373 int ecode4 = 0 ;
36374 int val5 ;
36375 int ecode5 = 0 ;
36376 bool val6 ;
36377 int ecode6 = 0 ;
36378 PyObject * obj0 = 0 ;
36379 PyObject * obj1 = 0 ;
36380 PyObject * obj2 = 0 ;
36381 PyObject * obj3 = 0 ;
36382 PyObject * obj4 = 0 ;
36383 PyObject * obj5 = 0 ;
36384 char * kwnames[] = {
36385 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36386 };
36387
36388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36390 if (!SWIG_IsOK(res1)) {
36391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36392 }
36393 arg1 = reinterpret_cast< wxWindow * >(argp1);
36394 ecode2 = SWIG_AsVal_int(obj1, &val2);
36395 if (!SWIG_IsOK(ecode2)) {
36396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36397 }
36398 arg2 = static_cast< int >(val2);
36399 ecode3 = SWIG_AsVal_int(obj2, &val3);
36400 if (!SWIG_IsOK(ecode3)) {
36401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36402 }
36403 arg3 = static_cast< int >(val3);
36404 ecode4 = SWIG_AsVal_int(obj3, &val4);
36405 if (!SWIG_IsOK(ecode4)) {
36406 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36407 }
36408 arg4 = static_cast< int >(val4);
36409 ecode5 = SWIG_AsVal_int(obj4, &val5);
36410 if (!SWIG_IsOK(ecode5)) {
36411 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36412 }
36413 arg5 = static_cast< int >(val5);
36414 if (obj5) {
36415 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36416 if (!SWIG_IsOK(ecode6)) {
36417 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36418 }
36419 arg6 = static_cast< bool >(val6);
36420 }
36421 {
36422 PyThreadState* __tstate = wxPyBeginAllowThreads();
36423 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36424 wxPyEndAllowThreads(__tstate);
36425 if (PyErr_Occurred()) SWIG_fail;
36426 }
36427 resultobj = SWIG_Py_Void();
36428 return resultobj;
36429 fail:
36430 return NULL;
36431 }
36432
36433
36434 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36435 PyObject *resultobj = 0;
36436 wxWindow *arg1 = (wxWindow *) 0 ;
36437 int arg2 ;
36438 int arg3 ;
36439 bool arg4 = (bool) true ;
36440 void *argp1 = 0 ;
36441 int res1 = 0 ;
36442 int val2 ;
36443 int ecode2 = 0 ;
36444 int val3 ;
36445 int ecode3 = 0 ;
36446 bool val4 ;
36447 int ecode4 = 0 ;
36448 PyObject * obj0 = 0 ;
36449 PyObject * obj1 = 0 ;
36450 PyObject * obj2 = 0 ;
36451 PyObject * obj3 = 0 ;
36452 char * kwnames[] = {
36453 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36454 };
36455
36456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36458 if (!SWIG_IsOK(res1)) {
36459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36460 }
36461 arg1 = reinterpret_cast< wxWindow * >(argp1);
36462 ecode2 = SWIG_AsVal_int(obj1, &val2);
36463 if (!SWIG_IsOK(ecode2)) {
36464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36465 }
36466 arg2 = static_cast< int >(val2);
36467 ecode3 = SWIG_AsVal_int(obj2, &val3);
36468 if (!SWIG_IsOK(ecode3)) {
36469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36470 }
36471 arg3 = static_cast< int >(val3);
36472 if (obj3) {
36473 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36474 if (!SWIG_IsOK(ecode4)) {
36475 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36476 }
36477 arg4 = static_cast< bool >(val4);
36478 }
36479 {
36480 PyThreadState* __tstate = wxPyBeginAllowThreads();
36481 (arg1)->SetScrollPos(arg2,arg3,arg4);
36482 wxPyEndAllowThreads(__tstate);
36483 if (PyErr_Occurred()) SWIG_fail;
36484 }
36485 resultobj = SWIG_Py_Void();
36486 return resultobj;
36487 fail:
36488 return NULL;
36489 }
36490
36491
36492 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36493 PyObject *resultobj = 0;
36494 wxWindow *arg1 = (wxWindow *) 0 ;
36495 int arg2 ;
36496 int result;
36497 void *argp1 = 0 ;
36498 int res1 = 0 ;
36499 int val2 ;
36500 int ecode2 = 0 ;
36501 PyObject * obj0 = 0 ;
36502 PyObject * obj1 = 0 ;
36503 char * kwnames[] = {
36504 (char *) "self",(char *) "orientation", NULL
36505 };
36506
36507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36509 if (!SWIG_IsOK(res1)) {
36510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36511 }
36512 arg1 = reinterpret_cast< wxWindow * >(argp1);
36513 ecode2 = SWIG_AsVal_int(obj1, &val2);
36514 if (!SWIG_IsOK(ecode2)) {
36515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36516 }
36517 arg2 = static_cast< int >(val2);
36518 {
36519 PyThreadState* __tstate = wxPyBeginAllowThreads();
36520 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36521 wxPyEndAllowThreads(__tstate);
36522 if (PyErr_Occurred()) SWIG_fail;
36523 }
36524 resultobj = SWIG_From_int(static_cast< int >(result));
36525 return resultobj;
36526 fail:
36527 return NULL;
36528 }
36529
36530
36531 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36532 PyObject *resultobj = 0;
36533 wxWindow *arg1 = (wxWindow *) 0 ;
36534 int arg2 ;
36535 int result;
36536 void *argp1 = 0 ;
36537 int res1 = 0 ;
36538 int val2 ;
36539 int ecode2 = 0 ;
36540 PyObject * obj0 = 0 ;
36541 PyObject * obj1 = 0 ;
36542 char * kwnames[] = {
36543 (char *) "self",(char *) "orientation", NULL
36544 };
36545
36546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36548 if (!SWIG_IsOK(res1)) {
36549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36550 }
36551 arg1 = reinterpret_cast< wxWindow * >(argp1);
36552 ecode2 = SWIG_AsVal_int(obj1, &val2);
36553 if (!SWIG_IsOK(ecode2)) {
36554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36555 }
36556 arg2 = static_cast< int >(val2);
36557 {
36558 PyThreadState* __tstate = wxPyBeginAllowThreads();
36559 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36560 wxPyEndAllowThreads(__tstate);
36561 if (PyErr_Occurred()) SWIG_fail;
36562 }
36563 resultobj = SWIG_From_int(static_cast< int >(result));
36564 return resultobj;
36565 fail:
36566 return NULL;
36567 }
36568
36569
36570 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36571 PyObject *resultobj = 0;
36572 wxWindow *arg1 = (wxWindow *) 0 ;
36573 int arg2 ;
36574 int result;
36575 void *argp1 = 0 ;
36576 int res1 = 0 ;
36577 int val2 ;
36578 int ecode2 = 0 ;
36579 PyObject * obj0 = 0 ;
36580 PyObject * obj1 = 0 ;
36581 char * kwnames[] = {
36582 (char *) "self",(char *) "orientation", NULL
36583 };
36584
36585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36587 if (!SWIG_IsOK(res1)) {
36588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36589 }
36590 arg1 = reinterpret_cast< wxWindow * >(argp1);
36591 ecode2 = SWIG_AsVal_int(obj1, &val2);
36592 if (!SWIG_IsOK(ecode2)) {
36593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36594 }
36595 arg2 = static_cast< int >(val2);
36596 {
36597 PyThreadState* __tstate = wxPyBeginAllowThreads();
36598 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36599 wxPyEndAllowThreads(__tstate);
36600 if (PyErr_Occurred()) SWIG_fail;
36601 }
36602 resultobj = SWIG_From_int(static_cast< int >(result));
36603 return resultobj;
36604 fail:
36605 return NULL;
36606 }
36607
36608
36609 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36610 PyObject *resultobj = 0;
36611 wxWindow *arg1 = (wxWindow *) 0 ;
36612 int arg2 ;
36613 int arg3 ;
36614 wxRect *arg4 = (wxRect *) NULL ;
36615 void *argp1 = 0 ;
36616 int res1 = 0 ;
36617 int val2 ;
36618 int ecode2 = 0 ;
36619 int val3 ;
36620 int ecode3 = 0 ;
36621 void *argp4 = 0 ;
36622 int res4 = 0 ;
36623 PyObject * obj0 = 0 ;
36624 PyObject * obj1 = 0 ;
36625 PyObject * obj2 = 0 ;
36626 PyObject * obj3 = 0 ;
36627 char * kwnames[] = {
36628 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36629 };
36630
36631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36633 if (!SWIG_IsOK(res1)) {
36634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36635 }
36636 arg1 = reinterpret_cast< wxWindow * >(argp1);
36637 ecode2 = SWIG_AsVal_int(obj1, &val2);
36638 if (!SWIG_IsOK(ecode2)) {
36639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36640 }
36641 arg2 = static_cast< int >(val2);
36642 ecode3 = SWIG_AsVal_int(obj2, &val3);
36643 if (!SWIG_IsOK(ecode3)) {
36644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36645 }
36646 arg3 = static_cast< int >(val3);
36647 if (obj3) {
36648 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36649 if (!SWIG_IsOK(res4)) {
36650 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36651 }
36652 arg4 = reinterpret_cast< wxRect * >(argp4);
36653 }
36654 {
36655 PyThreadState* __tstate = wxPyBeginAllowThreads();
36656 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36657 wxPyEndAllowThreads(__tstate);
36658 if (PyErr_Occurred()) SWIG_fail;
36659 }
36660 resultobj = SWIG_Py_Void();
36661 return resultobj;
36662 fail:
36663 return NULL;
36664 }
36665
36666
36667 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36668 PyObject *resultobj = 0;
36669 wxWindow *arg1 = (wxWindow *) 0 ;
36670 int arg2 ;
36671 bool result;
36672 void *argp1 = 0 ;
36673 int res1 = 0 ;
36674 int val2 ;
36675 int ecode2 = 0 ;
36676 PyObject * obj0 = 0 ;
36677 PyObject * obj1 = 0 ;
36678 char * kwnames[] = {
36679 (char *) "self",(char *) "lines", NULL
36680 };
36681
36682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36684 if (!SWIG_IsOK(res1)) {
36685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36686 }
36687 arg1 = reinterpret_cast< wxWindow * >(argp1);
36688 ecode2 = SWIG_AsVal_int(obj1, &val2);
36689 if (!SWIG_IsOK(ecode2)) {
36690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36691 }
36692 arg2 = static_cast< int >(val2);
36693 {
36694 PyThreadState* __tstate = wxPyBeginAllowThreads();
36695 result = (bool)(arg1)->ScrollLines(arg2);
36696 wxPyEndAllowThreads(__tstate);
36697 if (PyErr_Occurred()) SWIG_fail;
36698 }
36699 {
36700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36701 }
36702 return resultobj;
36703 fail:
36704 return NULL;
36705 }
36706
36707
36708 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36709 PyObject *resultobj = 0;
36710 wxWindow *arg1 = (wxWindow *) 0 ;
36711 int arg2 ;
36712 bool result;
36713 void *argp1 = 0 ;
36714 int res1 = 0 ;
36715 int val2 ;
36716 int ecode2 = 0 ;
36717 PyObject * obj0 = 0 ;
36718 PyObject * obj1 = 0 ;
36719 char * kwnames[] = {
36720 (char *) "self",(char *) "pages", NULL
36721 };
36722
36723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36725 if (!SWIG_IsOK(res1)) {
36726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36727 }
36728 arg1 = reinterpret_cast< wxWindow * >(argp1);
36729 ecode2 = SWIG_AsVal_int(obj1, &val2);
36730 if (!SWIG_IsOK(ecode2)) {
36731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36732 }
36733 arg2 = static_cast< int >(val2);
36734 {
36735 PyThreadState* __tstate = wxPyBeginAllowThreads();
36736 result = (bool)(arg1)->ScrollPages(arg2);
36737 wxPyEndAllowThreads(__tstate);
36738 if (PyErr_Occurred()) SWIG_fail;
36739 }
36740 {
36741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36742 }
36743 return resultobj;
36744 fail:
36745 return NULL;
36746 }
36747
36748
36749 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36750 PyObject *resultobj = 0;
36751 wxWindow *arg1 = (wxWindow *) 0 ;
36752 bool result;
36753 void *argp1 = 0 ;
36754 int res1 = 0 ;
36755 PyObject *swig_obj[1] ;
36756
36757 if (!args) SWIG_fail;
36758 swig_obj[0] = args;
36759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36760 if (!SWIG_IsOK(res1)) {
36761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36762 }
36763 arg1 = reinterpret_cast< wxWindow * >(argp1);
36764 {
36765 PyThreadState* __tstate = wxPyBeginAllowThreads();
36766 result = (bool)(arg1)->LineUp();
36767 wxPyEndAllowThreads(__tstate);
36768 if (PyErr_Occurred()) SWIG_fail;
36769 }
36770 {
36771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36772 }
36773 return resultobj;
36774 fail:
36775 return NULL;
36776 }
36777
36778
36779 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36780 PyObject *resultobj = 0;
36781 wxWindow *arg1 = (wxWindow *) 0 ;
36782 bool result;
36783 void *argp1 = 0 ;
36784 int res1 = 0 ;
36785 PyObject *swig_obj[1] ;
36786
36787 if (!args) SWIG_fail;
36788 swig_obj[0] = args;
36789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36790 if (!SWIG_IsOK(res1)) {
36791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36792 }
36793 arg1 = reinterpret_cast< wxWindow * >(argp1);
36794 {
36795 PyThreadState* __tstate = wxPyBeginAllowThreads();
36796 result = (bool)(arg1)->LineDown();
36797 wxPyEndAllowThreads(__tstate);
36798 if (PyErr_Occurred()) SWIG_fail;
36799 }
36800 {
36801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36802 }
36803 return resultobj;
36804 fail:
36805 return NULL;
36806 }
36807
36808
36809 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36810 PyObject *resultobj = 0;
36811 wxWindow *arg1 = (wxWindow *) 0 ;
36812 bool result;
36813 void *argp1 = 0 ;
36814 int res1 = 0 ;
36815 PyObject *swig_obj[1] ;
36816
36817 if (!args) SWIG_fail;
36818 swig_obj[0] = args;
36819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36820 if (!SWIG_IsOK(res1)) {
36821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36822 }
36823 arg1 = reinterpret_cast< wxWindow * >(argp1);
36824 {
36825 PyThreadState* __tstate = wxPyBeginAllowThreads();
36826 result = (bool)(arg1)->PageUp();
36827 wxPyEndAllowThreads(__tstate);
36828 if (PyErr_Occurred()) SWIG_fail;
36829 }
36830 {
36831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36832 }
36833 return resultobj;
36834 fail:
36835 return NULL;
36836 }
36837
36838
36839 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36840 PyObject *resultobj = 0;
36841 wxWindow *arg1 = (wxWindow *) 0 ;
36842 bool result;
36843 void *argp1 = 0 ;
36844 int res1 = 0 ;
36845 PyObject *swig_obj[1] ;
36846
36847 if (!args) SWIG_fail;
36848 swig_obj[0] = args;
36849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36850 if (!SWIG_IsOK(res1)) {
36851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36852 }
36853 arg1 = reinterpret_cast< wxWindow * >(argp1);
36854 {
36855 PyThreadState* __tstate = wxPyBeginAllowThreads();
36856 result = (bool)(arg1)->PageDown();
36857 wxPyEndAllowThreads(__tstate);
36858 if (PyErr_Occurred()) SWIG_fail;
36859 }
36860 {
36861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36862 }
36863 return resultobj;
36864 fail:
36865 return NULL;
36866 }
36867
36868
36869 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36870 PyObject *resultobj = 0;
36871 wxWindow *arg1 = (wxWindow *) 0 ;
36872 wxString *arg2 = 0 ;
36873 void *argp1 = 0 ;
36874 int res1 = 0 ;
36875 bool temp2 = false ;
36876 PyObject * obj0 = 0 ;
36877 PyObject * obj1 = 0 ;
36878 char * kwnames[] = {
36879 (char *) "self",(char *) "text", NULL
36880 };
36881
36882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36884 if (!SWIG_IsOK(res1)) {
36885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36886 }
36887 arg1 = reinterpret_cast< wxWindow * >(argp1);
36888 {
36889 arg2 = wxString_in_helper(obj1);
36890 if (arg2 == NULL) SWIG_fail;
36891 temp2 = true;
36892 }
36893 {
36894 PyThreadState* __tstate = wxPyBeginAllowThreads();
36895 (arg1)->SetHelpText((wxString const &)*arg2);
36896 wxPyEndAllowThreads(__tstate);
36897 if (PyErr_Occurred()) SWIG_fail;
36898 }
36899 resultobj = SWIG_Py_Void();
36900 {
36901 if (temp2)
36902 delete arg2;
36903 }
36904 return resultobj;
36905 fail:
36906 {
36907 if (temp2)
36908 delete arg2;
36909 }
36910 return NULL;
36911 }
36912
36913
36914 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36915 PyObject *resultobj = 0;
36916 wxWindow *arg1 = (wxWindow *) 0 ;
36917 wxString *arg2 = 0 ;
36918 void *argp1 = 0 ;
36919 int res1 = 0 ;
36920 bool temp2 = false ;
36921 PyObject * obj0 = 0 ;
36922 PyObject * obj1 = 0 ;
36923 char * kwnames[] = {
36924 (char *) "self",(char *) "text", NULL
36925 };
36926
36927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36929 if (!SWIG_IsOK(res1)) {
36930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36931 }
36932 arg1 = reinterpret_cast< wxWindow * >(argp1);
36933 {
36934 arg2 = wxString_in_helper(obj1);
36935 if (arg2 == NULL) SWIG_fail;
36936 temp2 = true;
36937 }
36938 {
36939 PyThreadState* __tstate = wxPyBeginAllowThreads();
36940 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36941 wxPyEndAllowThreads(__tstate);
36942 if (PyErr_Occurred()) SWIG_fail;
36943 }
36944 resultobj = SWIG_Py_Void();
36945 {
36946 if (temp2)
36947 delete arg2;
36948 }
36949 return resultobj;
36950 fail:
36951 {
36952 if (temp2)
36953 delete arg2;
36954 }
36955 return NULL;
36956 }
36957
36958
36959 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36960 PyObject *resultobj = 0;
36961 wxWindow *arg1 = (wxWindow *) 0 ;
36962 wxPoint *arg2 = 0 ;
36963 wxHelpEvent::Origin arg3 ;
36964 wxString result;
36965 void *argp1 = 0 ;
36966 int res1 = 0 ;
36967 wxPoint temp2 ;
36968 void *argp3 ;
36969 int res3 = 0 ;
36970 PyObject * obj0 = 0 ;
36971 PyObject * obj1 = 0 ;
36972 PyObject * obj2 = 0 ;
36973 char * kwnames[] = {
36974 (char *) "self",(char *) "pt",(char *) "origin", NULL
36975 };
36976
36977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36979 if (!SWIG_IsOK(res1)) {
36980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
36981 }
36982 arg1 = reinterpret_cast< wxWindow * >(argp1);
36983 {
36984 arg2 = &temp2;
36985 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36986 }
36987 {
36988 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
36989 if (!SWIG_IsOK(res3)) {
36990 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36991 }
36992 if (!argp3) {
36993 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36994 } else {
36995 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
36996 arg3 = *temp;
36997 if (SWIG_IsNewObj(res3)) delete temp;
36998 }
36999 }
37000 {
37001 PyThreadState* __tstate = wxPyBeginAllowThreads();
37002 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37003 wxPyEndAllowThreads(__tstate);
37004 if (PyErr_Occurred()) SWIG_fail;
37005 }
37006 {
37007 #if wxUSE_UNICODE
37008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37009 #else
37010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37011 #endif
37012 }
37013 return resultobj;
37014 fail:
37015 return NULL;
37016 }
37017
37018
37019 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37020 PyObject *resultobj = 0;
37021 wxWindow *arg1 = (wxWindow *) 0 ;
37022 wxString result;
37023 void *argp1 = 0 ;
37024 int res1 = 0 ;
37025 PyObject *swig_obj[1] ;
37026
37027 if (!args) SWIG_fail;
37028 swig_obj[0] = args;
37029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37030 if (!SWIG_IsOK(res1)) {
37031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37032 }
37033 arg1 = reinterpret_cast< wxWindow * >(argp1);
37034 {
37035 PyThreadState* __tstate = wxPyBeginAllowThreads();
37036 result = ((wxWindow const *)arg1)->GetHelpText();
37037 wxPyEndAllowThreads(__tstate);
37038 if (PyErr_Occurred()) SWIG_fail;
37039 }
37040 {
37041 #if wxUSE_UNICODE
37042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37043 #else
37044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37045 #endif
37046 }
37047 return resultobj;
37048 fail:
37049 return NULL;
37050 }
37051
37052
37053 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37054 PyObject *resultobj = 0;
37055 wxWindow *arg1 = (wxWindow *) 0 ;
37056 wxString *arg2 = 0 ;
37057 void *argp1 = 0 ;
37058 int res1 = 0 ;
37059 bool temp2 = false ;
37060 PyObject * obj0 = 0 ;
37061 PyObject * obj1 = 0 ;
37062 char * kwnames[] = {
37063 (char *) "self",(char *) "tip", NULL
37064 };
37065
37066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37068 if (!SWIG_IsOK(res1)) {
37069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37070 }
37071 arg1 = reinterpret_cast< wxWindow * >(argp1);
37072 {
37073 arg2 = wxString_in_helper(obj1);
37074 if (arg2 == NULL) SWIG_fail;
37075 temp2 = true;
37076 }
37077 {
37078 PyThreadState* __tstate = wxPyBeginAllowThreads();
37079 (arg1)->SetToolTip((wxString const &)*arg2);
37080 wxPyEndAllowThreads(__tstate);
37081 if (PyErr_Occurred()) SWIG_fail;
37082 }
37083 resultobj = SWIG_Py_Void();
37084 {
37085 if (temp2)
37086 delete arg2;
37087 }
37088 return resultobj;
37089 fail:
37090 {
37091 if (temp2)
37092 delete arg2;
37093 }
37094 return NULL;
37095 }
37096
37097
37098 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37099 PyObject *resultobj = 0;
37100 wxWindow *arg1 = (wxWindow *) 0 ;
37101 wxToolTip *arg2 = (wxToolTip *) 0 ;
37102 void *argp1 = 0 ;
37103 int res1 = 0 ;
37104 int res2 = 0 ;
37105 PyObject * obj0 = 0 ;
37106 PyObject * obj1 = 0 ;
37107 char * kwnames[] = {
37108 (char *) "self",(char *) "tip", NULL
37109 };
37110
37111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37113 if (!SWIG_IsOK(res1)) {
37114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37115 }
37116 arg1 = reinterpret_cast< wxWindow * >(argp1);
37117 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37118 if (!SWIG_IsOK(res2)) {
37119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37120 }
37121 {
37122 PyThreadState* __tstate = wxPyBeginAllowThreads();
37123 (arg1)->SetToolTip(arg2);
37124 wxPyEndAllowThreads(__tstate);
37125 if (PyErr_Occurred()) SWIG_fail;
37126 }
37127 resultobj = SWIG_Py_Void();
37128 return resultobj;
37129 fail:
37130 return NULL;
37131 }
37132
37133
37134 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37135 PyObject *resultobj = 0;
37136 wxWindow *arg1 = (wxWindow *) 0 ;
37137 wxToolTip *result = 0 ;
37138 void *argp1 = 0 ;
37139 int res1 = 0 ;
37140 PyObject *swig_obj[1] ;
37141
37142 if (!args) SWIG_fail;
37143 swig_obj[0] = args;
37144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37145 if (!SWIG_IsOK(res1)) {
37146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37147 }
37148 arg1 = reinterpret_cast< wxWindow * >(argp1);
37149 {
37150 PyThreadState* __tstate = wxPyBeginAllowThreads();
37151 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37152 wxPyEndAllowThreads(__tstate);
37153 if (PyErr_Occurred()) SWIG_fail;
37154 }
37155 {
37156 resultobj = wxPyMake_wxObject(result, (bool)0);
37157 }
37158 return resultobj;
37159 fail:
37160 return NULL;
37161 }
37162
37163
37164 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37165 PyObject *resultobj = 0;
37166 wxWindow *arg1 = (wxWindow *) 0 ;
37167 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37168 void *argp1 = 0 ;
37169 int res1 = 0 ;
37170 int res2 = 0 ;
37171 PyObject * obj0 = 0 ;
37172 PyObject * obj1 = 0 ;
37173 char * kwnames[] = {
37174 (char *) "self",(char *) "dropTarget", NULL
37175 };
37176
37177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37179 if (!SWIG_IsOK(res1)) {
37180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37181 }
37182 arg1 = reinterpret_cast< wxWindow * >(argp1);
37183 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37184 if (!SWIG_IsOK(res2)) {
37185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37186 }
37187 {
37188 PyThreadState* __tstate = wxPyBeginAllowThreads();
37189 (arg1)->SetDropTarget(arg2);
37190 wxPyEndAllowThreads(__tstate);
37191 if (PyErr_Occurred()) SWIG_fail;
37192 }
37193 resultobj = SWIG_Py_Void();
37194 return resultobj;
37195 fail:
37196 return NULL;
37197 }
37198
37199
37200 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37201 PyObject *resultobj = 0;
37202 wxWindow *arg1 = (wxWindow *) 0 ;
37203 wxPyDropTarget *result = 0 ;
37204 void *argp1 = 0 ;
37205 int res1 = 0 ;
37206 PyObject *swig_obj[1] ;
37207
37208 if (!args) SWIG_fail;
37209 swig_obj[0] = args;
37210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37211 if (!SWIG_IsOK(res1)) {
37212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37213 }
37214 arg1 = reinterpret_cast< wxWindow * >(argp1);
37215 {
37216 PyThreadState* __tstate = wxPyBeginAllowThreads();
37217 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37218 wxPyEndAllowThreads(__tstate);
37219 if (PyErr_Occurred()) SWIG_fail;
37220 }
37221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37222 return resultobj;
37223 fail:
37224 return NULL;
37225 }
37226
37227
37228 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37229 PyObject *resultobj = 0;
37230 wxWindow *arg1 = (wxWindow *) 0 ;
37231 bool arg2 ;
37232 void *argp1 = 0 ;
37233 int res1 = 0 ;
37234 bool val2 ;
37235 int ecode2 = 0 ;
37236 PyObject * obj0 = 0 ;
37237 PyObject * obj1 = 0 ;
37238 char * kwnames[] = {
37239 (char *) "self",(char *) "accept", NULL
37240 };
37241
37242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37244 if (!SWIG_IsOK(res1)) {
37245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37246 }
37247 arg1 = reinterpret_cast< wxWindow * >(argp1);
37248 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37249 if (!SWIG_IsOK(ecode2)) {
37250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37251 }
37252 arg2 = static_cast< bool >(val2);
37253 {
37254 PyThreadState* __tstate = wxPyBeginAllowThreads();
37255 wxWindow_DragAcceptFiles(arg1,arg2);
37256 wxPyEndAllowThreads(__tstate);
37257 if (PyErr_Occurred()) SWIG_fail;
37258 }
37259 resultobj = SWIG_Py_Void();
37260 return resultobj;
37261 fail:
37262 return NULL;
37263 }
37264
37265
37266 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37267 PyObject *resultobj = 0;
37268 wxWindow *arg1 = (wxWindow *) 0 ;
37269 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37270 void *argp1 = 0 ;
37271 int res1 = 0 ;
37272 int res2 = 0 ;
37273 PyObject * obj0 = 0 ;
37274 PyObject * obj1 = 0 ;
37275 char * kwnames[] = {
37276 (char *) "self",(char *) "constraints", NULL
37277 };
37278
37279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37281 if (!SWIG_IsOK(res1)) {
37282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37283 }
37284 arg1 = reinterpret_cast< wxWindow * >(argp1);
37285 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37286 if (!SWIG_IsOK(res2)) {
37287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37288 }
37289 {
37290 PyThreadState* __tstate = wxPyBeginAllowThreads();
37291 (arg1)->SetConstraints(arg2);
37292 wxPyEndAllowThreads(__tstate);
37293 if (PyErr_Occurred()) SWIG_fail;
37294 }
37295 resultobj = SWIG_Py_Void();
37296 return resultobj;
37297 fail:
37298 return NULL;
37299 }
37300
37301
37302 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37303 PyObject *resultobj = 0;
37304 wxWindow *arg1 = (wxWindow *) 0 ;
37305 wxLayoutConstraints *result = 0 ;
37306 void *argp1 = 0 ;
37307 int res1 = 0 ;
37308 PyObject *swig_obj[1] ;
37309
37310 if (!args) SWIG_fail;
37311 swig_obj[0] = args;
37312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37313 if (!SWIG_IsOK(res1)) {
37314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37315 }
37316 arg1 = reinterpret_cast< wxWindow * >(argp1);
37317 {
37318 PyThreadState* __tstate = wxPyBeginAllowThreads();
37319 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37320 wxPyEndAllowThreads(__tstate);
37321 if (PyErr_Occurred()) SWIG_fail;
37322 }
37323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37324 return resultobj;
37325 fail:
37326 return NULL;
37327 }
37328
37329
37330 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37331 PyObject *resultobj = 0;
37332 wxWindow *arg1 = (wxWindow *) 0 ;
37333 bool arg2 ;
37334 void *argp1 = 0 ;
37335 int res1 = 0 ;
37336 bool val2 ;
37337 int ecode2 = 0 ;
37338 PyObject * obj0 = 0 ;
37339 PyObject * obj1 = 0 ;
37340 char * kwnames[] = {
37341 (char *) "self",(char *) "autoLayout", NULL
37342 };
37343
37344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37346 if (!SWIG_IsOK(res1)) {
37347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37348 }
37349 arg1 = reinterpret_cast< wxWindow * >(argp1);
37350 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37351 if (!SWIG_IsOK(ecode2)) {
37352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37353 }
37354 arg2 = static_cast< bool >(val2);
37355 {
37356 PyThreadState* __tstate = wxPyBeginAllowThreads();
37357 (arg1)->SetAutoLayout(arg2);
37358 wxPyEndAllowThreads(__tstate);
37359 if (PyErr_Occurred()) SWIG_fail;
37360 }
37361 resultobj = SWIG_Py_Void();
37362 return resultobj;
37363 fail:
37364 return NULL;
37365 }
37366
37367
37368 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37369 PyObject *resultobj = 0;
37370 wxWindow *arg1 = (wxWindow *) 0 ;
37371 bool result;
37372 void *argp1 = 0 ;
37373 int res1 = 0 ;
37374 PyObject *swig_obj[1] ;
37375
37376 if (!args) SWIG_fail;
37377 swig_obj[0] = args;
37378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37379 if (!SWIG_IsOK(res1)) {
37380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37381 }
37382 arg1 = reinterpret_cast< wxWindow * >(argp1);
37383 {
37384 PyThreadState* __tstate = wxPyBeginAllowThreads();
37385 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37386 wxPyEndAllowThreads(__tstate);
37387 if (PyErr_Occurred()) SWIG_fail;
37388 }
37389 {
37390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37391 }
37392 return resultobj;
37393 fail:
37394 return NULL;
37395 }
37396
37397
37398 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37399 PyObject *resultobj = 0;
37400 wxWindow *arg1 = (wxWindow *) 0 ;
37401 bool result;
37402 void *argp1 = 0 ;
37403 int res1 = 0 ;
37404 PyObject *swig_obj[1] ;
37405
37406 if (!args) SWIG_fail;
37407 swig_obj[0] = args;
37408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37409 if (!SWIG_IsOK(res1)) {
37410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37411 }
37412 arg1 = reinterpret_cast< wxWindow * >(argp1);
37413 {
37414 PyThreadState* __tstate = wxPyBeginAllowThreads();
37415 result = (bool)(arg1)->Layout();
37416 wxPyEndAllowThreads(__tstate);
37417 if (PyErr_Occurred()) SWIG_fail;
37418 }
37419 {
37420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37421 }
37422 return resultobj;
37423 fail:
37424 return NULL;
37425 }
37426
37427
37428 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37429 PyObject *resultobj = 0;
37430 wxWindow *arg1 = (wxWindow *) 0 ;
37431 wxSizer *arg2 = (wxSizer *) 0 ;
37432 bool arg3 = (bool) true ;
37433 void *argp1 = 0 ;
37434 int res1 = 0 ;
37435 int res2 = 0 ;
37436 bool val3 ;
37437 int ecode3 = 0 ;
37438 PyObject * obj0 = 0 ;
37439 PyObject * obj1 = 0 ;
37440 PyObject * obj2 = 0 ;
37441 char * kwnames[] = {
37442 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37443 };
37444
37445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37447 if (!SWIG_IsOK(res1)) {
37448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37449 }
37450 arg1 = reinterpret_cast< wxWindow * >(argp1);
37451 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37452 if (!SWIG_IsOK(res2)) {
37453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37454 }
37455 if (obj2) {
37456 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37457 if (!SWIG_IsOK(ecode3)) {
37458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37459 }
37460 arg3 = static_cast< bool >(val3);
37461 }
37462 {
37463 PyThreadState* __tstate = wxPyBeginAllowThreads();
37464 (arg1)->SetSizer(arg2,arg3);
37465 wxPyEndAllowThreads(__tstate);
37466 if (PyErr_Occurred()) SWIG_fail;
37467 }
37468 resultobj = SWIG_Py_Void();
37469 return resultobj;
37470 fail:
37471 return NULL;
37472 }
37473
37474
37475 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37476 PyObject *resultobj = 0;
37477 wxWindow *arg1 = (wxWindow *) 0 ;
37478 wxSizer *arg2 = (wxSizer *) 0 ;
37479 bool arg3 = (bool) true ;
37480 void *argp1 = 0 ;
37481 int res1 = 0 ;
37482 int res2 = 0 ;
37483 bool val3 ;
37484 int ecode3 = 0 ;
37485 PyObject * obj0 = 0 ;
37486 PyObject * obj1 = 0 ;
37487 PyObject * obj2 = 0 ;
37488 char * kwnames[] = {
37489 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37490 };
37491
37492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37494 if (!SWIG_IsOK(res1)) {
37495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37496 }
37497 arg1 = reinterpret_cast< wxWindow * >(argp1);
37498 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37499 if (!SWIG_IsOK(res2)) {
37500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37501 }
37502 if (obj2) {
37503 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37504 if (!SWIG_IsOK(ecode3)) {
37505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37506 }
37507 arg3 = static_cast< bool >(val3);
37508 }
37509 {
37510 PyThreadState* __tstate = wxPyBeginAllowThreads();
37511 (arg1)->SetSizerAndFit(arg2,arg3);
37512 wxPyEndAllowThreads(__tstate);
37513 if (PyErr_Occurred()) SWIG_fail;
37514 }
37515 resultobj = SWIG_Py_Void();
37516 return resultobj;
37517 fail:
37518 return NULL;
37519 }
37520
37521
37522 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37523 PyObject *resultobj = 0;
37524 wxWindow *arg1 = (wxWindow *) 0 ;
37525 wxSizer *result = 0 ;
37526 void *argp1 = 0 ;
37527 int res1 = 0 ;
37528 PyObject *swig_obj[1] ;
37529
37530 if (!args) SWIG_fail;
37531 swig_obj[0] = args;
37532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37533 if (!SWIG_IsOK(res1)) {
37534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37535 }
37536 arg1 = reinterpret_cast< wxWindow * >(argp1);
37537 {
37538 PyThreadState* __tstate = wxPyBeginAllowThreads();
37539 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37540 wxPyEndAllowThreads(__tstate);
37541 if (PyErr_Occurred()) SWIG_fail;
37542 }
37543 {
37544 resultobj = wxPyMake_wxObject(result, (bool)0);
37545 }
37546 return resultobj;
37547 fail:
37548 return NULL;
37549 }
37550
37551
37552 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37553 PyObject *resultobj = 0;
37554 wxWindow *arg1 = (wxWindow *) 0 ;
37555 wxSizer *arg2 = (wxSizer *) 0 ;
37556 void *argp1 = 0 ;
37557 int res1 = 0 ;
37558 void *argp2 = 0 ;
37559 int res2 = 0 ;
37560 PyObject * obj0 = 0 ;
37561 PyObject * obj1 = 0 ;
37562 char * kwnames[] = {
37563 (char *) "self",(char *) "sizer", NULL
37564 };
37565
37566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37568 if (!SWIG_IsOK(res1)) {
37569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37570 }
37571 arg1 = reinterpret_cast< wxWindow * >(argp1);
37572 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37573 if (!SWIG_IsOK(res2)) {
37574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37575 }
37576 arg2 = reinterpret_cast< wxSizer * >(argp2);
37577 {
37578 PyThreadState* __tstate = wxPyBeginAllowThreads();
37579 (arg1)->SetContainingSizer(arg2);
37580 wxPyEndAllowThreads(__tstate);
37581 if (PyErr_Occurred()) SWIG_fail;
37582 }
37583 resultobj = SWIG_Py_Void();
37584 return resultobj;
37585 fail:
37586 return NULL;
37587 }
37588
37589
37590 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37591 PyObject *resultobj = 0;
37592 wxWindow *arg1 = (wxWindow *) 0 ;
37593 wxSizer *result = 0 ;
37594 void *argp1 = 0 ;
37595 int res1 = 0 ;
37596 PyObject *swig_obj[1] ;
37597
37598 if (!args) SWIG_fail;
37599 swig_obj[0] = args;
37600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37601 if (!SWIG_IsOK(res1)) {
37602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37603 }
37604 arg1 = reinterpret_cast< wxWindow * >(argp1);
37605 {
37606 PyThreadState* __tstate = wxPyBeginAllowThreads();
37607 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37608 wxPyEndAllowThreads(__tstate);
37609 if (PyErr_Occurred()) SWIG_fail;
37610 }
37611 {
37612 resultobj = wxPyMake_wxObject(result, (bool)0);
37613 }
37614 return resultobj;
37615 fail:
37616 return NULL;
37617 }
37618
37619
37620 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37621 PyObject *resultobj = 0;
37622 wxWindow *arg1 = (wxWindow *) 0 ;
37623 void *argp1 = 0 ;
37624 int res1 = 0 ;
37625 PyObject *swig_obj[1] ;
37626
37627 if (!args) SWIG_fail;
37628 swig_obj[0] = args;
37629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37630 if (!SWIG_IsOK(res1)) {
37631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37632 }
37633 arg1 = reinterpret_cast< wxWindow * >(argp1);
37634 {
37635 PyThreadState* __tstate = wxPyBeginAllowThreads();
37636 (arg1)->InheritAttributes();
37637 wxPyEndAllowThreads(__tstate);
37638 if (PyErr_Occurred()) SWIG_fail;
37639 }
37640 resultobj = SWIG_Py_Void();
37641 return resultobj;
37642 fail:
37643 return NULL;
37644 }
37645
37646
37647 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37648 PyObject *resultobj = 0;
37649 wxWindow *arg1 = (wxWindow *) 0 ;
37650 bool result;
37651 void *argp1 = 0 ;
37652 int res1 = 0 ;
37653 PyObject *swig_obj[1] ;
37654
37655 if (!args) SWIG_fail;
37656 swig_obj[0] = args;
37657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37658 if (!SWIG_IsOK(res1)) {
37659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37660 }
37661 arg1 = reinterpret_cast< wxWindow * >(argp1);
37662 {
37663 PyThreadState* __tstate = wxPyBeginAllowThreads();
37664 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37665 wxPyEndAllowThreads(__tstate);
37666 if (PyErr_Occurred()) SWIG_fail;
37667 }
37668 {
37669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37670 }
37671 return resultobj;
37672 fail:
37673 return NULL;
37674 }
37675
37676
37677 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37678 PyObject *obj;
37679 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37680 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37681 return SWIG_Py_Void();
37682 }
37683
37684 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37685 return SWIG_Python_InitShadowInstance(args);
37686 }
37687
37688 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37689 PyObject *resultobj = 0;
37690 long arg1 ;
37691 wxWindow *arg2 = (wxWindow *) NULL ;
37692 wxWindow *result = 0 ;
37693 long val1 ;
37694 int ecode1 = 0 ;
37695 void *argp2 = 0 ;
37696 int res2 = 0 ;
37697 PyObject * obj0 = 0 ;
37698 PyObject * obj1 = 0 ;
37699 char * kwnames[] = {
37700 (char *) "id",(char *) "parent", NULL
37701 };
37702
37703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37704 ecode1 = SWIG_AsVal_long(obj0, &val1);
37705 if (!SWIG_IsOK(ecode1)) {
37706 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37707 }
37708 arg1 = static_cast< long >(val1);
37709 if (obj1) {
37710 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37711 if (!SWIG_IsOK(res2)) {
37712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37713 }
37714 arg2 = reinterpret_cast< wxWindow * >(argp2);
37715 }
37716 {
37717 if (!wxPyCheckForApp()) SWIG_fail;
37718 PyThreadState* __tstate = wxPyBeginAllowThreads();
37719 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37720 wxPyEndAllowThreads(__tstate);
37721 if (PyErr_Occurred()) SWIG_fail;
37722 }
37723 {
37724 resultobj = wxPyMake_wxObject(result, 0);
37725 }
37726 return resultobj;
37727 fail:
37728 return NULL;
37729 }
37730
37731
37732 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37733 PyObject *resultobj = 0;
37734 wxString *arg1 = 0 ;
37735 wxWindow *arg2 = (wxWindow *) NULL ;
37736 wxWindow *result = 0 ;
37737 bool temp1 = false ;
37738 void *argp2 = 0 ;
37739 int res2 = 0 ;
37740 PyObject * obj0 = 0 ;
37741 PyObject * obj1 = 0 ;
37742 char * kwnames[] = {
37743 (char *) "name",(char *) "parent", NULL
37744 };
37745
37746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37747 {
37748 arg1 = wxString_in_helper(obj0);
37749 if (arg1 == NULL) SWIG_fail;
37750 temp1 = true;
37751 }
37752 if (obj1) {
37753 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37754 if (!SWIG_IsOK(res2)) {
37755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37756 }
37757 arg2 = reinterpret_cast< wxWindow * >(argp2);
37758 }
37759 {
37760 if (!wxPyCheckForApp()) SWIG_fail;
37761 PyThreadState* __tstate = wxPyBeginAllowThreads();
37762 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37763 wxPyEndAllowThreads(__tstate);
37764 if (PyErr_Occurred()) SWIG_fail;
37765 }
37766 {
37767 resultobj = wxPyMake_wxObject(result, 0);
37768 }
37769 {
37770 if (temp1)
37771 delete arg1;
37772 }
37773 return resultobj;
37774 fail:
37775 {
37776 if (temp1)
37777 delete arg1;
37778 }
37779 return NULL;
37780 }
37781
37782
37783 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37784 PyObject *resultobj = 0;
37785 wxString *arg1 = 0 ;
37786 wxWindow *arg2 = (wxWindow *) NULL ;
37787 wxWindow *result = 0 ;
37788 bool temp1 = false ;
37789 void *argp2 = 0 ;
37790 int res2 = 0 ;
37791 PyObject * obj0 = 0 ;
37792 PyObject * obj1 = 0 ;
37793 char * kwnames[] = {
37794 (char *) "label",(char *) "parent", NULL
37795 };
37796
37797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37798 {
37799 arg1 = wxString_in_helper(obj0);
37800 if (arg1 == NULL) SWIG_fail;
37801 temp1 = true;
37802 }
37803 if (obj1) {
37804 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37805 if (!SWIG_IsOK(res2)) {
37806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37807 }
37808 arg2 = reinterpret_cast< wxWindow * >(argp2);
37809 }
37810 {
37811 if (!wxPyCheckForApp()) SWIG_fail;
37812 PyThreadState* __tstate = wxPyBeginAllowThreads();
37813 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37814 wxPyEndAllowThreads(__tstate);
37815 if (PyErr_Occurred()) SWIG_fail;
37816 }
37817 {
37818 resultobj = wxPyMake_wxObject(result, 0);
37819 }
37820 {
37821 if (temp1)
37822 delete arg1;
37823 }
37824 return resultobj;
37825 fail:
37826 {
37827 if (temp1)
37828 delete arg1;
37829 }
37830 return NULL;
37831 }
37832
37833
37834 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37835 PyObject *resultobj = 0;
37836 wxWindow *arg1 = (wxWindow *) 0 ;
37837 unsigned long arg2 ;
37838 wxWindow *result = 0 ;
37839 void *argp1 = 0 ;
37840 int res1 = 0 ;
37841 unsigned long val2 ;
37842 int ecode2 = 0 ;
37843 PyObject * obj0 = 0 ;
37844 PyObject * obj1 = 0 ;
37845 char * kwnames[] = {
37846 (char *) "parent",(char *) "_hWnd", NULL
37847 };
37848
37849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37851 if (!SWIG_IsOK(res1)) {
37852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37853 }
37854 arg1 = reinterpret_cast< wxWindow * >(argp1);
37855 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37856 if (!SWIG_IsOK(ecode2)) {
37857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37858 }
37859 arg2 = static_cast< unsigned long >(val2);
37860 {
37861 PyThreadState* __tstate = wxPyBeginAllowThreads();
37862 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37863 wxPyEndAllowThreads(__tstate);
37864 if (PyErr_Occurred()) SWIG_fail;
37865 }
37866 {
37867 resultobj = wxPyMake_wxObject(result, 0);
37868 }
37869 return resultobj;
37870 fail:
37871 return NULL;
37872 }
37873
37874
37875 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37876 PyObject *resultobj = 0;
37877 PyObject *result = 0 ;
37878
37879 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37880 {
37881 PyThreadState* __tstate = wxPyBeginAllowThreads();
37882 result = (PyObject *)GetTopLevelWindows();
37883 wxPyEndAllowThreads(__tstate);
37884 if (PyErr_Occurred()) SWIG_fail;
37885 }
37886 resultobj = result;
37887 return resultobj;
37888 fail:
37889 return NULL;
37890 }
37891
37892
37893 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37894 PyObject *resultobj = 0;
37895 wxValidator *result = 0 ;
37896
37897 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37898 {
37899 PyThreadState* __tstate = wxPyBeginAllowThreads();
37900 result = (wxValidator *)new wxValidator();
37901 wxPyEndAllowThreads(__tstate);
37902 if (PyErr_Occurred()) SWIG_fail;
37903 }
37904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37905 return resultobj;
37906 fail:
37907 return NULL;
37908 }
37909
37910
37911 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37912 PyObject *resultobj = 0;
37913 wxValidator *arg1 = (wxValidator *) 0 ;
37914 wxValidator *result = 0 ;
37915 void *argp1 = 0 ;
37916 int res1 = 0 ;
37917 PyObject *swig_obj[1] ;
37918
37919 if (!args) SWIG_fail;
37920 swig_obj[0] = args;
37921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37922 if (!SWIG_IsOK(res1)) {
37923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37924 }
37925 arg1 = reinterpret_cast< wxValidator * >(argp1);
37926 {
37927 PyThreadState* __tstate = wxPyBeginAllowThreads();
37928 result = (wxValidator *)(arg1)->Clone();
37929 wxPyEndAllowThreads(__tstate);
37930 if (PyErr_Occurred()) SWIG_fail;
37931 }
37932 {
37933 resultobj = wxPyMake_wxObject(result, 0);
37934 }
37935 return resultobj;
37936 fail:
37937 return NULL;
37938 }
37939
37940
37941 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37942 PyObject *resultobj = 0;
37943 wxValidator *arg1 = (wxValidator *) 0 ;
37944 wxWindow *arg2 = (wxWindow *) 0 ;
37945 bool result;
37946 void *argp1 = 0 ;
37947 int res1 = 0 ;
37948 void *argp2 = 0 ;
37949 int res2 = 0 ;
37950 PyObject * obj0 = 0 ;
37951 PyObject * obj1 = 0 ;
37952 char * kwnames[] = {
37953 (char *) "self",(char *) "parent", NULL
37954 };
37955
37956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37958 if (!SWIG_IsOK(res1)) {
37959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37960 }
37961 arg1 = reinterpret_cast< wxValidator * >(argp1);
37962 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37963 if (!SWIG_IsOK(res2)) {
37964 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37965 }
37966 arg2 = reinterpret_cast< wxWindow * >(argp2);
37967 {
37968 PyThreadState* __tstate = wxPyBeginAllowThreads();
37969 result = (bool)(arg1)->Validate(arg2);
37970 wxPyEndAllowThreads(__tstate);
37971 if (PyErr_Occurred()) SWIG_fail;
37972 }
37973 {
37974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37975 }
37976 return resultobj;
37977 fail:
37978 return NULL;
37979 }
37980
37981
37982 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37983 PyObject *resultobj = 0;
37984 wxValidator *arg1 = (wxValidator *) 0 ;
37985 bool result;
37986 void *argp1 = 0 ;
37987 int res1 = 0 ;
37988 PyObject *swig_obj[1] ;
37989
37990 if (!args) SWIG_fail;
37991 swig_obj[0] = args;
37992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37993 if (!SWIG_IsOK(res1)) {
37994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37995 }
37996 arg1 = reinterpret_cast< wxValidator * >(argp1);
37997 {
37998 PyThreadState* __tstate = wxPyBeginAllowThreads();
37999 result = (bool)(arg1)->TransferToWindow();
38000 wxPyEndAllowThreads(__tstate);
38001 if (PyErr_Occurred()) SWIG_fail;
38002 }
38003 {
38004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38005 }
38006 return resultobj;
38007 fail:
38008 return NULL;
38009 }
38010
38011
38012 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38013 PyObject *resultobj = 0;
38014 wxValidator *arg1 = (wxValidator *) 0 ;
38015 bool result;
38016 void *argp1 = 0 ;
38017 int res1 = 0 ;
38018 PyObject *swig_obj[1] ;
38019
38020 if (!args) SWIG_fail;
38021 swig_obj[0] = args;
38022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38023 if (!SWIG_IsOK(res1)) {
38024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38025 }
38026 arg1 = reinterpret_cast< wxValidator * >(argp1);
38027 {
38028 PyThreadState* __tstate = wxPyBeginAllowThreads();
38029 result = (bool)(arg1)->TransferFromWindow();
38030 wxPyEndAllowThreads(__tstate);
38031 if (PyErr_Occurred()) SWIG_fail;
38032 }
38033 {
38034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38035 }
38036 return resultobj;
38037 fail:
38038 return NULL;
38039 }
38040
38041
38042 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38043 PyObject *resultobj = 0;
38044 wxValidator *arg1 = (wxValidator *) 0 ;
38045 wxWindow *result = 0 ;
38046 void *argp1 = 0 ;
38047 int res1 = 0 ;
38048 PyObject *swig_obj[1] ;
38049
38050 if (!args) SWIG_fail;
38051 swig_obj[0] = args;
38052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38053 if (!SWIG_IsOK(res1)) {
38054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38055 }
38056 arg1 = reinterpret_cast< wxValidator * >(argp1);
38057 {
38058 PyThreadState* __tstate = wxPyBeginAllowThreads();
38059 result = (wxWindow *)(arg1)->GetWindow();
38060 wxPyEndAllowThreads(__tstate);
38061 if (PyErr_Occurred()) SWIG_fail;
38062 }
38063 {
38064 resultobj = wxPyMake_wxObject(result, 0);
38065 }
38066 return resultobj;
38067 fail:
38068 return NULL;
38069 }
38070
38071
38072 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38073 PyObject *resultobj = 0;
38074 wxValidator *arg1 = (wxValidator *) 0 ;
38075 wxWindow *arg2 = (wxWindow *) 0 ;
38076 void *argp1 = 0 ;
38077 int res1 = 0 ;
38078 void *argp2 = 0 ;
38079 int res2 = 0 ;
38080 PyObject * obj0 = 0 ;
38081 PyObject * obj1 = 0 ;
38082 char * kwnames[] = {
38083 (char *) "self",(char *) "window", NULL
38084 };
38085
38086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38088 if (!SWIG_IsOK(res1)) {
38089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38090 }
38091 arg1 = reinterpret_cast< wxValidator * >(argp1);
38092 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38093 if (!SWIG_IsOK(res2)) {
38094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38095 }
38096 arg2 = reinterpret_cast< wxWindow * >(argp2);
38097 {
38098 PyThreadState* __tstate = wxPyBeginAllowThreads();
38099 (arg1)->SetWindow(arg2);
38100 wxPyEndAllowThreads(__tstate);
38101 if (PyErr_Occurred()) SWIG_fail;
38102 }
38103 resultobj = SWIG_Py_Void();
38104 return resultobj;
38105 fail:
38106 return NULL;
38107 }
38108
38109
38110 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38111 PyObject *resultobj = 0;
38112 bool result;
38113
38114 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38115 {
38116 PyThreadState* __tstate = wxPyBeginAllowThreads();
38117 result = (bool)wxValidator::IsSilent();
38118 wxPyEndAllowThreads(__tstate);
38119 if (PyErr_Occurred()) SWIG_fail;
38120 }
38121 {
38122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38123 }
38124 return resultobj;
38125 fail:
38126 return NULL;
38127 }
38128
38129
38130 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38131 PyObject *resultobj = 0;
38132 int arg1 = (int) true ;
38133 int val1 ;
38134 int ecode1 = 0 ;
38135 PyObject * obj0 = 0 ;
38136 char * kwnames[] = {
38137 (char *) "doIt", NULL
38138 };
38139
38140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38141 if (obj0) {
38142 ecode1 = SWIG_AsVal_int(obj0, &val1);
38143 if (!SWIG_IsOK(ecode1)) {
38144 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38145 }
38146 arg1 = static_cast< int >(val1);
38147 }
38148 {
38149 PyThreadState* __tstate = wxPyBeginAllowThreads();
38150 wxValidator::SetBellOnError(arg1);
38151 wxPyEndAllowThreads(__tstate);
38152 if (PyErr_Occurred()) SWIG_fail;
38153 }
38154 resultobj = SWIG_Py_Void();
38155 return resultobj;
38156 fail:
38157 return NULL;
38158 }
38159
38160
38161 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38162 PyObject *obj;
38163 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38164 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38165 return SWIG_Py_Void();
38166 }
38167
38168 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38169 return SWIG_Python_InitShadowInstance(args);
38170 }
38171
38172 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38173 PyObject *resultobj = 0;
38174 wxPyValidator *result = 0 ;
38175
38176 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38177 {
38178 PyThreadState* __tstate = wxPyBeginAllowThreads();
38179 result = (wxPyValidator *)new wxPyValidator();
38180 wxPyEndAllowThreads(__tstate);
38181 if (PyErr_Occurred()) SWIG_fail;
38182 }
38183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38184 return resultobj;
38185 fail:
38186 return NULL;
38187 }
38188
38189
38190 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38191 PyObject *resultobj = 0;
38192 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38193 PyObject *arg2 = (PyObject *) 0 ;
38194 PyObject *arg3 = (PyObject *) 0 ;
38195 int arg4 = (int) true ;
38196 void *argp1 = 0 ;
38197 int res1 = 0 ;
38198 int val4 ;
38199 int ecode4 = 0 ;
38200 PyObject * obj0 = 0 ;
38201 PyObject * obj1 = 0 ;
38202 PyObject * obj2 = 0 ;
38203 PyObject * obj3 = 0 ;
38204 char * kwnames[] = {
38205 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38206 };
38207
38208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38210 if (!SWIG_IsOK(res1)) {
38211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38212 }
38213 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38214 arg2 = obj1;
38215 arg3 = obj2;
38216 if (obj3) {
38217 ecode4 = SWIG_AsVal_int(obj3, &val4);
38218 if (!SWIG_IsOK(ecode4)) {
38219 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38220 }
38221 arg4 = static_cast< int >(val4);
38222 }
38223 {
38224 PyThreadState* __tstate = wxPyBeginAllowThreads();
38225 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38226 wxPyEndAllowThreads(__tstate);
38227 if (PyErr_Occurred()) SWIG_fail;
38228 }
38229 resultobj = SWIG_Py_Void();
38230 return resultobj;
38231 fail:
38232 return NULL;
38233 }
38234
38235
38236 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38237 PyObject *obj;
38238 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38239 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38240 return SWIG_Py_Void();
38241 }
38242
38243 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38244 return SWIG_Python_InitShadowInstance(args);
38245 }
38246
38247 SWIGINTERN int DefaultValidator_set(PyObject *) {
38248 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38249 return 1;
38250 }
38251
38252
38253 SWIGINTERN PyObject *DefaultValidator_get(void) {
38254 PyObject *pyobj = 0;
38255
38256 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38257 return pyobj;
38258 }
38259
38260
38261 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38262 PyObject *resultobj = 0;
38263 wxString const &arg1_defvalue = wxPyEmptyString ;
38264 wxString *arg1 = (wxString *) &arg1_defvalue ;
38265 long arg2 = (long) 0 ;
38266 wxMenu *result = 0 ;
38267 bool temp1 = false ;
38268 long val2 ;
38269 int ecode2 = 0 ;
38270 PyObject * obj0 = 0 ;
38271 PyObject * obj1 = 0 ;
38272 char * kwnames[] = {
38273 (char *) "title",(char *) "style", NULL
38274 };
38275
38276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38277 if (obj0) {
38278 {
38279 arg1 = wxString_in_helper(obj0);
38280 if (arg1 == NULL) SWIG_fail;
38281 temp1 = true;
38282 }
38283 }
38284 if (obj1) {
38285 ecode2 = SWIG_AsVal_long(obj1, &val2);
38286 if (!SWIG_IsOK(ecode2)) {
38287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38288 }
38289 arg2 = static_cast< long >(val2);
38290 }
38291 {
38292 if (!wxPyCheckForApp()) SWIG_fail;
38293 PyThreadState* __tstate = wxPyBeginAllowThreads();
38294 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38295 wxPyEndAllowThreads(__tstate);
38296 if (PyErr_Occurred()) SWIG_fail;
38297 }
38298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38299 {
38300 if (temp1)
38301 delete arg1;
38302 }
38303 return resultobj;
38304 fail:
38305 {
38306 if (temp1)
38307 delete arg1;
38308 }
38309 return NULL;
38310 }
38311
38312
38313 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38314 PyObject *resultobj = 0;
38315 wxMenu *arg1 = (wxMenu *) 0 ;
38316 int arg2 ;
38317 wxString *arg3 = 0 ;
38318 wxString const &arg4_defvalue = wxPyEmptyString ;
38319 wxString *arg4 = (wxString *) &arg4_defvalue ;
38320 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38321 wxMenuItem *result = 0 ;
38322 void *argp1 = 0 ;
38323 int res1 = 0 ;
38324 int val2 ;
38325 int ecode2 = 0 ;
38326 bool temp3 = false ;
38327 bool temp4 = false ;
38328 int val5 ;
38329 int ecode5 = 0 ;
38330 PyObject * obj0 = 0 ;
38331 PyObject * obj1 = 0 ;
38332 PyObject * obj2 = 0 ;
38333 PyObject * obj3 = 0 ;
38334 PyObject * obj4 = 0 ;
38335 char * kwnames[] = {
38336 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38337 };
38338
38339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38341 if (!SWIG_IsOK(res1)) {
38342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38343 }
38344 arg1 = reinterpret_cast< wxMenu * >(argp1);
38345 ecode2 = SWIG_AsVal_int(obj1, &val2);
38346 if (!SWIG_IsOK(ecode2)) {
38347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38348 }
38349 arg2 = static_cast< int >(val2);
38350 {
38351 arg3 = wxString_in_helper(obj2);
38352 if (arg3 == NULL) SWIG_fail;
38353 temp3 = true;
38354 }
38355 if (obj3) {
38356 {
38357 arg4 = wxString_in_helper(obj3);
38358 if (arg4 == NULL) SWIG_fail;
38359 temp4 = true;
38360 }
38361 }
38362 if (obj4) {
38363 ecode5 = SWIG_AsVal_int(obj4, &val5);
38364 if (!SWIG_IsOK(ecode5)) {
38365 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38366 }
38367 arg5 = static_cast< wxItemKind >(val5);
38368 }
38369 {
38370 PyThreadState* __tstate = wxPyBeginAllowThreads();
38371 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38372 wxPyEndAllowThreads(__tstate);
38373 if (PyErr_Occurred()) SWIG_fail;
38374 }
38375 {
38376 resultobj = wxPyMake_wxObject(result, (bool)0);
38377 }
38378 {
38379 if (temp3)
38380 delete arg3;
38381 }
38382 {
38383 if (temp4)
38384 delete arg4;
38385 }
38386 return resultobj;
38387 fail:
38388 {
38389 if (temp3)
38390 delete arg3;
38391 }
38392 {
38393 if (temp4)
38394 delete arg4;
38395 }
38396 return NULL;
38397 }
38398
38399
38400 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38401 PyObject *resultobj = 0;
38402 wxMenu *arg1 = (wxMenu *) 0 ;
38403 wxMenuItem *result = 0 ;
38404 void *argp1 = 0 ;
38405 int res1 = 0 ;
38406 PyObject *swig_obj[1] ;
38407
38408 if (!args) SWIG_fail;
38409 swig_obj[0] = args;
38410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38411 if (!SWIG_IsOK(res1)) {
38412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38413 }
38414 arg1 = reinterpret_cast< wxMenu * >(argp1);
38415 {
38416 PyThreadState* __tstate = wxPyBeginAllowThreads();
38417 result = (wxMenuItem *)(arg1)->AppendSeparator();
38418 wxPyEndAllowThreads(__tstate);
38419 if (PyErr_Occurred()) SWIG_fail;
38420 }
38421 {
38422 resultobj = wxPyMake_wxObject(result, (bool)0);
38423 }
38424 return resultobj;
38425 fail:
38426 return NULL;
38427 }
38428
38429
38430 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38431 PyObject *resultobj = 0;
38432 wxMenu *arg1 = (wxMenu *) 0 ;
38433 int arg2 ;
38434 wxString *arg3 = 0 ;
38435 wxString const &arg4_defvalue = wxPyEmptyString ;
38436 wxString *arg4 = (wxString *) &arg4_defvalue ;
38437 wxMenuItem *result = 0 ;
38438 void *argp1 = 0 ;
38439 int res1 = 0 ;
38440 int val2 ;
38441 int ecode2 = 0 ;
38442 bool temp3 = false ;
38443 bool temp4 = false ;
38444 PyObject * obj0 = 0 ;
38445 PyObject * obj1 = 0 ;
38446 PyObject * obj2 = 0 ;
38447 PyObject * obj3 = 0 ;
38448 char * kwnames[] = {
38449 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38450 };
38451
38452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38454 if (!SWIG_IsOK(res1)) {
38455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38456 }
38457 arg1 = reinterpret_cast< wxMenu * >(argp1);
38458 ecode2 = SWIG_AsVal_int(obj1, &val2);
38459 if (!SWIG_IsOK(ecode2)) {
38460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38461 }
38462 arg2 = static_cast< int >(val2);
38463 {
38464 arg3 = wxString_in_helper(obj2);
38465 if (arg3 == NULL) SWIG_fail;
38466 temp3 = true;
38467 }
38468 if (obj3) {
38469 {
38470 arg4 = wxString_in_helper(obj3);
38471 if (arg4 == NULL) SWIG_fail;
38472 temp4 = true;
38473 }
38474 }
38475 {
38476 PyThreadState* __tstate = wxPyBeginAllowThreads();
38477 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38478 wxPyEndAllowThreads(__tstate);
38479 if (PyErr_Occurred()) SWIG_fail;
38480 }
38481 {
38482 resultobj = wxPyMake_wxObject(result, (bool)0);
38483 }
38484 {
38485 if (temp3)
38486 delete arg3;
38487 }
38488 {
38489 if (temp4)
38490 delete arg4;
38491 }
38492 return resultobj;
38493 fail:
38494 {
38495 if (temp3)
38496 delete arg3;
38497 }
38498 {
38499 if (temp4)
38500 delete arg4;
38501 }
38502 return NULL;
38503 }
38504
38505
38506 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38507 PyObject *resultobj = 0;
38508 wxMenu *arg1 = (wxMenu *) 0 ;
38509 int arg2 ;
38510 wxString *arg3 = 0 ;
38511 wxString const &arg4_defvalue = wxPyEmptyString ;
38512 wxString *arg4 = (wxString *) &arg4_defvalue ;
38513 wxMenuItem *result = 0 ;
38514 void *argp1 = 0 ;
38515 int res1 = 0 ;
38516 int val2 ;
38517 int ecode2 = 0 ;
38518 bool temp3 = false ;
38519 bool temp4 = false ;
38520 PyObject * obj0 = 0 ;
38521 PyObject * obj1 = 0 ;
38522 PyObject * obj2 = 0 ;
38523 PyObject * obj3 = 0 ;
38524 char * kwnames[] = {
38525 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38526 };
38527
38528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38530 if (!SWIG_IsOK(res1)) {
38531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38532 }
38533 arg1 = reinterpret_cast< wxMenu * >(argp1);
38534 ecode2 = SWIG_AsVal_int(obj1, &val2);
38535 if (!SWIG_IsOK(ecode2)) {
38536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38537 }
38538 arg2 = static_cast< int >(val2);
38539 {
38540 arg3 = wxString_in_helper(obj2);
38541 if (arg3 == NULL) SWIG_fail;
38542 temp3 = true;
38543 }
38544 if (obj3) {
38545 {
38546 arg4 = wxString_in_helper(obj3);
38547 if (arg4 == NULL) SWIG_fail;
38548 temp4 = true;
38549 }
38550 }
38551 {
38552 PyThreadState* __tstate = wxPyBeginAllowThreads();
38553 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38554 wxPyEndAllowThreads(__tstate);
38555 if (PyErr_Occurred()) SWIG_fail;
38556 }
38557 {
38558 resultobj = wxPyMake_wxObject(result, (bool)0);
38559 }
38560 {
38561 if (temp3)
38562 delete arg3;
38563 }
38564 {
38565 if (temp4)
38566 delete arg4;
38567 }
38568 return resultobj;
38569 fail:
38570 {
38571 if (temp3)
38572 delete arg3;
38573 }
38574 {
38575 if (temp4)
38576 delete arg4;
38577 }
38578 return NULL;
38579 }
38580
38581
38582 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38583 PyObject *resultobj = 0;
38584 wxMenu *arg1 = (wxMenu *) 0 ;
38585 int arg2 ;
38586 wxString *arg3 = 0 ;
38587 wxMenu *arg4 = (wxMenu *) 0 ;
38588 wxString const &arg5_defvalue = wxPyEmptyString ;
38589 wxString *arg5 = (wxString *) &arg5_defvalue ;
38590 wxMenuItem *result = 0 ;
38591 void *argp1 = 0 ;
38592 int res1 = 0 ;
38593 int val2 ;
38594 int ecode2 = 0 ;
38595 bool temp3 = false ;
38596 void *argp4 = 0 ;
38597 int res4 = 0 ;
38598 bool temp5 = false ;
38599 PyObject * obj0 = 0 ;
38600 PyObject * obj1 = 0 ;
38601 PyObject * obj2 = 0 ;
38602 PyObject * obj3 = 0 ;
38603 PyObject * obj4 = 0 ;
38604 char * kwnames[] = {
38605 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38606 };
38607
38608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38610 if (!SWIG_IsOK(res1)) {
38611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38612 }
38613 arg1 = reinterpret_cast< wxMenu * >(argp1);
38614 ecode2 = SWIG_AsVal_int(obj1, &val2);
38615 if (!SWIG_IsOK(ecode2)) {
38616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38617 }
38618 arg2 = static_cast< int >(val2);
38619 {
38620 arg3 = wxString_in_helper(obj2);
38621 if (arg3 == NULL) SWIG_fail;
38622 temp3 = true;
38623 }
38624 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38625 if (!SWIG_IsOK(res4)) {
38626 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38627 }
38628 arg4 = reinterpret_cast< wxMenu * >(argp4);
38629 if (obj4) {
38630 {
38631 arg5 = wxString_in_helper(obj4);
38632 if (arg5 == NULL) SWIG_fail;
38633 temp5 = true;
38634 }
38635 }
38636 {
38637 PyThreadState* __tstate = wxPyBeginAllowThreads();
38638 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38639 wxPyEndAllowThreads(__tstate);
38640 if (PyErr_Occurred()) SWIG_fail;
38641 }
38642 {
38643 resultobj = wxPyMake_wxObject(result, (bool)0);
38644 }
38645 {
38646 if (temp3)
38647 delete arg3;
38648 }
38649 {
38650 if (temp5)
38651 delete arg5;
38652 }
38653 return resultobj;
38654 fail:
38655 {
38656 if (temp3)
38657 delete arg3;
38658 }
38659 {
38660 if (temp5)
38661 delete arg5;
38662 }
38663 return NULL;
38664 }
38665
38666
38667 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38668 PyObject *resultobj = 0;
38669 wxMenu *arg1 = (wxMenu *) 0 ;
38670 wxMenu *arg2 = (wxMenu *) 0 ;
38671 wxString *arg3 = 0 ;
38672 wxString const &arg4_defvalue = wxPyEmptyString ;
38673 wxString *arg4 = (wxString *) &arg4_defvalue ;
38674 wxMenuItem *result = 0 ;
38675 void *argp1 = 0 ;
38676 int res1 = 0 ;
38677 void *argp2 = 0 ;
38678 int res2 = 0 ;
38679 bool temp3 = false ;
38680 bool temp4 = false ;
38681 PyObject * obj0 = 0 ;
38682 PyObject * obj1 = 0 ;
38683 PyObject * obj2 = 0 ;
38684 PyObject * obj3 = 0 ;
38685 char * kwnames[] = {
38686 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38687 };
38688
38689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38691 if (!SWIG_IsOK(res1)) {
38692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38693 }
38694 arg1 = reinterpret_cast< wxMenu * >(argp1);
38695 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38696 if (!SWIG_IsOK(res2)) {
38697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38698 }
38699 arg2 = reinterpret_cast< wxMenu * >(argp2);
38700 {
38701 arg3 = wxString_in_helper(obj2);
38702 if (arg3 == NULL) SWIG_fail;
38703 temp3 = true;
38704 }
38705 if (obj3) {
38706 {
38707 arg4 = wxString_in_helper(obj3);
38708 if (arg4 == NULL) SWIG_fail;
38709 temp4 = true;
38710 }
38711 }
38712 {
38713 PyThreadState* __tstate = wxPyBeginAllowThreads();
38714 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38715 wxPyEndAllowThreads(__tstate);
38716 if (PyErr_Occurred()) SWIG_fail;
38717 }
38718 {
38719 resultobj = wxPyMake_wxObject(result, (bool)0);
38720 }
38721 {
38722 if (temp3)
38723 delete arg3;
38724 }
38725 {
38726 if (temp4)
38727 delete arg4;
38728 }
38729 return resultobj;
38730 fail:
38731 {
38732 if (temp3)
38733 delete arg3;
38734 }
38735 {
38736 if (temp4)
38737 delete arg4;
38738 }
38739 return NULL;
38740 }
38741
38742
38743 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38744 PyObject *resultobj = 0;
38745 wxMenu *arg1 = (wxMenu *) 0 ;
38746 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38747 wxMenuItem *result = 0 ;
38748 void *argp1 = 0 ;
38749 int res1 = 0 ;
38750 int res2 = 0 ;
38751 PyObject * obj0 = 0 ;
38752 PyObject * obj1 = 0 ;
38753 char * kwnames[] = {
38754 (char *) "self",(char *) "item", NULL
38755 };
38756
38757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38759 if (!SWIG_IsOK(res1)) {
38760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38761 }
38762 arg1 = reinterpret_cast< wxMenu * >(argp1);
38763 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38764 if (!SWIG_IsOK(res2)) {
38765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38766 }
38767 {
38768 PyThreadState* __tstate = wxPyBeginAllowThreads();
38769 result = (wxMenuItem *)(arg1)->Append(arg2);
38770 wxPyEndAllowThreads(__tstate);
38771 if (PyErr_Occurred()) SWIG_fail;
38772 }
38773 {
38774 resultobj = wxPyMake_wxObject(result, (bool)0);
38775 }
38776 return resultobj;
38777 fail:
38778 return NULL;
38779 }
38780
38781
38782 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38783 PyObject *resultobj = 0;
38784 wxMenu *arg1 = (wxMenu *) 0 ;
38785 size_t arg2 ;
38786 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38787 wxMenuItem *result = 0 ;
38788 void *argp1 = 0 ;
38789 int res1 = 0 ;
38790 size_t val2 ;
38791 int ecode2 = 0 ;
38792 int res3 = 0 ;
38793 PyObject * obj0 = 0 ;
38794 PyObject * obj1 = 0 ;
38795 PyObject * obj2 = 0 ;
38796 char * kwnames[] = {
38797 (char *) "self",(char *) "pos",(char *) "item", NULL
38798 };
38799
38800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38802 if (!SWIG_IsOK(res1)) {
38803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38804 }
38805 arg1 = reinterpret_cast< wxMenu * >(argp1);
38806 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38807 if (!SWIG_IsOK(ecode2)) {
38808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38809 }
38810 arg2 = static_cast< size_t >(val2);
38811 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38812 if (!SWIG_IsOK(res3)) {
38813 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38814 }
38815 {
38816 PyThreadState* __tstate = wxPyBeginAllowThreads();
38817 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38818 wxPyEndAllowThreads(__tstate);
38819 if (PyErr_Occurred()) SWIG_fail;
38820 }
38821 {
38822 resultobj = wxPyMake_wxObject(result, (bool)0);
38823 }
38824 return resultobj;
38825 fail:
38826 return NULL;
38827 }
38828
38829
38830 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38831 PyObject *resultobj = 0;
38832 wxMenu *arg1 = (wxMenu *) 0 ;
38833 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38834 wxMenuItem *result = 0 ;
38835 void *argp1 = 0 ;
38836 int res1 = 0 ;
38837 int res2 = 0 ;
38838 PyObject * obj0 = 0 ;
38839 PyObject * obj1 = 0 ;
38840 char * kwnames[] = {
38841 (char *) "self",(char *) "item", NULL
38842 };
38843
38844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38846 if (!SWIG_IsOK(res1)) {
38847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38848 }
38849 arg1 = reinterpret_cast< wxMenu * >(argp1);
38850 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38851 if (!SWIG_IsOK(res2)) {
38852 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38853 }
38854 {
38855 PyThreadState* __tstate = wxPyBeginAllowThreads();
38856 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38857 wxPyEndAllowThreads(__tstate);
38858 if (PyErr_Occurred()) SWIG_fail;
38859 }
38860 {
38861 resultobj = wxPyMake_wxObject(result, (bool)0);
38862 }
38863 return resultobj;
38864 fail:
38865 return NULL;
38866 }
38867
38868
38869 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38870 PyObject *resultobj = 0;
38871 wxMenu *arg1 = (wxMenu *) 0 ;
38872 void *argp1 = 0 ;
38873 int res1 = 0 ;
38874 PyObject *swig_obj[1] ;
38875
38876 if (!args) SWIG_fail;
38877 swig_obj[0] = args;
38878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38879 if (!SWIG_IsOK(res1)) {
38880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38881 }
38882 arg1 = reinterpret_cast< wxMenu * >(argp1);
38883 {
38884 PyThreadState* __tstate = wxPyBeginAllowThreads();
38885 (arg1)->Break();
38886 wxPyEndAllowThreads(__tstate);
38887 if (PyErr_Occurred()) SWIG_fail;
38888 }
38889 resultobj = SWIG_Py_Void();
38890 return resultobj;
38891 fail:
38892 return NULL;
38893 }
38894
38895
38896 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38897 PyObject *resultobj = 0;
38898 wxMenu *arg1 = (wxMenu *) 0 ;
38899 size_t arg2 ;
38900 int arg3 ;
38901 wxString *arg4 = 0 ;
38902 wxString const &arg5_defvalue = wxPyEmptyString ;
38903 wxString *arg5 = (wxString *) &arg5_defvalue ;
38904 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38905 wxMenuItem *result = 0 ;
38906 void *argp1 = 0 ;
38907 int res1 = 0 ;
38908 size_t val2 ;
38909 int ecode2 = 0 ;
38910 int val3 ;
38911 int ecode3 = 0 ;
38912 bool temp4 = false ;
38913 bool temp5 = false ;
38914 int val6 ;
38915 int ecode6 = 0 ;
38916 PyObject * obj0 = 0 ;
38917 PyObject * obj1 = 0 ;
38918 PyObject * obj2 = 0 ;
38919 PyObject * obj3 = 0 ;
38920 PyObject * obj4 = 0 ;
38921 PyObject * obj5 = 0 ;
38922 char * kwnames[] = {
38923 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38924 };
38925
38926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38928 if (!SWIG_IsOK(res1)) {
38929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38930 }
38931 arg1 = reinterpret_cast< wxMenu * >(argp1);
38932 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38933 if (!SWIG_IsOK(ecode2)) {
38934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38935 }
38936 arg2 = static_cast< size_t >(val2);
38937 ecode3 = SWIG_AsVal_int(obj2, &val3);
38938 if (!SWIG_IsOK(ecode3)) {
38939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38940 }
38941 arg3 = static_cast< int >(val3);
38942 {
38943 arg4 = wxString_in_helper(obj3);
38944 if (arg4 == NULL) SWIG_fail;
38945 temp4 = true;
38946 }
38947 if (obj4) {
38948 {
38949 arg5 = wxString_in_helper(obj4);
38950 if (arg5 == NULL) SWIG_fail;
38951 temp5 = true;
38952 }
38953 }
38954 if (obj5) {
38955 ecode6 = SWIG_AsVal_int(obj5, &val6);
38956 if (!SWIG_IsOK(ecode6)) {
38957 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38958 }
38959 arg6 = static_cast< wxItemKind >(val6);
38960 }
38961 {
38962 PyThreadState* __tstate = wxPyBeginAllowThreads();
38963 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38964 wxPyEndAllowThreads(__tstate);
38965 if (PyErr_Occurred()) SWIG_fail;
38966 }
38967 {
38968 resultobj = wxPyMake_wxObject(result, (bool)0);
38969 }
38970 {
38971 if (temp4)
38972 delete arg4;
38973 }
38974 {
38975 if (temp5)
38976 delete arg5;
38977 }
38978 return resultobj;
38979 fail:
38980 {
38981 if (temp4)
38982 delete arg4;
38983 }
38984 {
38985 if (temp5)
38986 delete arg5;
38987 }
38988 return NULL;
38989 }
38990
38991
38992 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38993 PyObject *resultobj = 0;
38994 wxMenu *arg1 = (wxMenu *) 0 ;
38995 size_t arg2 ;
38996 wxMenuItem *result = 0 ;
38997 void *argp1 = 0 ;
38998 int res1 = 0 ;
38999 size_t val2 ;
39000 int ecode2 = 0 ;
39001 PyObject * obj0 = 0 ;
39002 PyObject * obj1 = 0 ;
39003 char * kwnames[] = {
39004 (char *) "self",(char *) "pos", NULL
39005 };
39006
39007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39009 if (!SWIG_IsOK(res1)) {
39010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39011 }
39012 arg1 = reinterpret_cast< wxMenu * >(argp1);
39013 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39014 if (!SWIG_IsOK(ecode2)) {
39015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39016 }
39017 arg2 = static_cast< size_t >(val2);
39018 {
39019 PyThreadState* __tstate = wxPyBeginAllowThreads();
39020 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39021 wxPyEndAllowThreads(__tstate);
39022 if (PyErr_Occurred()) SWIG_fail;
39023 }
39024 {
39025 resultobj = wxPyMake_wxObject(result, (bool)0);
39026 }
39027 return resultobj;
39028 fail:
39029 return NULL;
39030 }
39031
39032
39033 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39034 PyObject *resultobj = 0;
39035 wxMenu *arg1 = (wxMenu *) 0 ;
39036 size_t arg2 ;
39037 int arg3 ;
39038 wxString *arg4 = 0 ;
39039 wxString const &arg5_defvalue = wxPyEmptyString ;
39040 wxString *arg5 = (wxString *) &arg5_defvalue ;
39041 wxMenuItem *result = 0 ;
39042 void *argp1 = 0 ;
39043 int res1 = 0 ;
39044 size_t val2 ;
39045 int ecode2 = 0 ;
39046 int val3 ;
39047 int ecode3 = 0 ;
39048 bool temp4 = false ;
39049 bool temp5 = false ;
39050 PyObject * obj0 = 0 ;
39051 PyObject * obj1 = 0 ;
39052 PyObject * obj2 = 0 ;
39053 PyObject * obj3 = 0 ;
39054 PyObject * obj4 = 0 ;
39055 char * kwnames[] = {
39056 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39057 };
39058
39059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39061 if (!SWIG_IsOK(res1)) {
39062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39063 }
39064 arg1 = reinterpret_cast< wxMenu * >(argp1);
39065 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39066 if (!SWIG_IsOK(ecode2)) {
39067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39068 }
39069 arg2 = static_cast< size_t >(val2);
39070 ecode3 = SWIG_AsVal_int(obj2, &val3);
39071 if (!SWIG_IsOK(ecode3)) {
39072 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39073 }
39074 arg3 = static_cast< int >(val3);
39075 {
39076 arg4 = wxString_in_helper(obj3);
39077 if (arg4 == NULL) SWIG_fail;
39078 temp4 = true;
39079 }
39080 if (obj4) {
39081 {
39082 arg5 = wxString_in_helper(obj4);
39083 if (arg5 == NULL) SWIG_fail;
39084 temp5 = true;
39085 }
39086 }
39087 {
39088 PyThreadState* __tstate = wxPyBeginAllowThreads();
39089 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39090 wxPyEndAllowThreads(__tstate);
39091 if (PyErr_Occurred()) SWIG_fail;
39092 }
39093 {
39094 resultobj = wxPyMake_wxObject(result, (bool)0);
39095 }
39096 {
39097 if (temp4)
39098 delete arg4;
39099 }
39100 {
39101 if (temp5)
39102 delete arg5;
39103 }
39104 return resultobj;
39105 fail:
39106 {
39107 if (temp4)
39108 delete arg4;
39109 }
39110 {
39111 if (temp5)
39112 delete arg5;
39113 }
39114 return NULL;
39115 }
39116
39117
39118 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39119 PyObject *resultobj = 0;
39120 wxMenu *arg1 = (wxMenu *) 0 ;
39121 size_t arg2 ;
39122 int arg3 ;
39123 wxString *arg4 = 0 ;
39124 wxString const &arg5_defvalue = wxPyEmptyString ;
39125 wxString *arg5 = (wxString *) &arg5_defvalue ;
39126 wxMenuItem *result = 0 ;
39127 void *argp1 = 0 ;
39128 int res1 = 0 ;
39129 size_t val2 ;
39130 int ecode2 = 0 ;
39131 int val3 ;
39132 int ecode3 = 0 ;
39133 bool temp4 = false ;
39134 bool temp5 = false ;
39135 PyObject * obj0 = 0 ;
39136 PyObject * obj1 = 0 ;
39137 PyObject * obj2 = 0 ;
39138 PyObject * obj3 = 0 ;
39139 PyObject * obj4 = 0 ;
39140 char * kwnames[] = {
39141 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39142 };
39143
39144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39146 if (!SWIG_IsOK(res1)) {
39147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39148 }
39149 arg1 = reinterpret_cast< wxMenu * >(argp1);
39150 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39151 if (!SWIG_IsOK(ecode2)) {
39152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39153 }
39154 arg2 = static_cast< size_t >(val2);
39155 ecode3 = SWIG_AsVal_int(obj2, &val3);
39156 if (!SWIG_IsOK(ecode3)) {
39157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39158 }
39159 arg3 = static_cast< int >(val3);
39160 {
39161 arg4 = wxString_in_helper(obj3);
39162 if (arg4 == NULL) SWIG_fail;
39163 temp4 = true;
39164 }
39165 if (obj4) {
39166 {
39167 arg5 = wxString_in_helper(obj4);
39168 if (arg5 == NULL) SWIG_fail;
39169 temp5 = true;
39170 }
39171 }
39172 {
39173 PyThreadState* __tstate = wxPyBeginAllowThreads();
39174 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39175 wxPyEndAllowThreads(__tstate);
39176 if (PyErr_Occurred()) SWIG_fail;
39177 }
39178 {
39179 resultobj = wxPyMake_wxObject(result, (bool)0);
39180 }
39181 {
39182 if (temp4)
39183 delete arg4;
39184 }
39185 {
39186 if (temp5)
39187 delete arg5;
39188 }
39189 return resultobj;
39190 fail:
39191 {
39192 if (temp4)
39193 delete arg4;
39194 }
39195 {
39196 if (temp5)
39197 delete arg5;
39198 }
39199 return NULL;
39200 }
39201
39202
39203 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39204 PyObject *resultobj = 0;
39205 wxMenu *arg1 = (wxMenu *) 0 ;
39206 size_t arg2 ;
39207 int arg3 ;
39208 wxString *arg4 = 0 ;
39209 wxMenu *arg5 = (wxMenu *) 0 ;
39210 wxString const &arg6_defvalue = wxPyEmptyString ;
39211 wxString *arg6 = (wxString *) &arg6_defvalue ;
39212 wxMenuItem *result = 0 ;
39213 void *argp1 = 0 ;
39214 int res1 = 0 ;
39215 size_t val2 ;
39216 int ecode2 = 0 ;
39217 int val3 ;
39218 int ecode3 = 0 ;
39219 bool temp4 = false ;
39220 void *argp5 = 0 ;
39221 int res5 = 0 ;
39222 bool temp6 = false ;
39223 PyObject * obj0 = 0 ;
39224 PyObject * obj1 = 0 ;
39225 PyObject * obj2 = 0 ;
39226 PyObject * obj3 = 0 ;
39227 PyObject * obj4 = 0 ;
39228 PyObject * obj5 = 0 ;
39229 char * kwnames[] = {
39230 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39231 };
39232
39233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39235 if (!SWIG_IsOK(res1)) {
39236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39237 }
39238 arg1 = reinterpret_cast< wxMenu * >(argp1);
39239 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39240 if (!SWIG_IsOK(ecode2)) {
39241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39242 }
39243 arg2 = static_cast< size_t >(val2);
39244 ecode3 = SWIG_AsVal_int(obj2, &val3);
39245 if (!SWIG_IsOK(ecode3)) {
39246 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39247 }
39248 arg3 = static_cast< int >(val3);
39249 {
39250 arg4 = wxString_in_helper(obj3);
39251 if (arg4 == NULL) SWIG_fail;
39252 temp4 = true;
39253 }
39254 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39255 if (!SWIG_IsOK(res5)) {
39256 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39257 }
39258 arg5 = reinterpret_cast< wxMenu * >(argp5);
39259 if (obj5) {
39260 {
39261 arg6 = wxString_in_helper(obj5);
39262 if (arg6 == NULL) SWIG_fail;
39263 temp6 = true;
39264 }
39265 }
39266 {
39267 PyThreadState* __tstate = wxPyBeginAllowThreads();
39268 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39269 wxPyEndAllowThreads(__tstate);
39270 if (PyErr_Occurred()) SWIG_fail;
39271 }
39272 {
39273 resultobj = wxPyMake_wxObject(result, (bool)0);
39274 }
39275 {
39276 if (temp4)
39277 delete arg4;
39278 }
39279 {
39280 if (temp6)
39281 delete arg6;
39282 }
39283 return resultobj;
39284 fail:
39285 {
39286 if (temp4)
39287 delete arg4;
39288 }
39289 {
39290 if (temp6)
39291 delete arg6;
39292 }
39293 return NULL;
39294 }
39295
39296
39297 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39298 PyObject *resultobj = 0;
39299 wxMenu *arg1 = (wxMenu *) 0 ;
39300 int arg2 ;
39301 wxString *arg3 = 0 ;
39302 wxString const &arg4_defvalue = wxPyEmptyString ;
39303 wxString *arg4 = (wxString *) &arg4_defvalue ;
39304 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39305 wxMenuItem *result = 0 ;
39306 void *argp1 = 0 ;
39307 int res1 = 0 ;
39308 int val2 ;
39309 int ecode2 = 0 ;
39310 bool temp3 = false ;
39311 bool temp4 = false ;
39312 int val5 ;
39313 int ecode5 = 0 ;
39314 PyObject * obj0 = 0 ;
39315 PyObject * obj1 = 0 ;
39316 PyObject * obj2 = 0 ;
39317 PyObject * obj3 = 0 ;
39318 PyObject * obj4 = 0 ;
39319 char * kwnames[] = {
39320 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39321 };
39322
39323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39325 if (!SWIG_IsOK(res1)) {
39326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39327 }
39328 arg1 = reinterpret_cast< wxMenu * >(argp1);
39329 ecode2 = SWIG_AsVal_int(obj1, &val2);
39330 if (!SWIG_IsOK(ecode2)) {
39331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39332 }
39333 arg2 = static_cast< int >(val2);
39334 {
39335 arg3 = wxString_in_helper(obj2);
39336 if (arg3 == NULL) SWIG_fail;
39337 temp3 = true;
39338 }
39339 if (obj3) {
39340 {
39341 arg4 = wxString_in_helper(obj3);
39342 if (arg4 == NULL) SWIG_fail;
39343 temp4 = true;
39344 }
39345 }
39346 if (obj4) {
39347 ecode5 = SWIG_AsVal_int(obj4, &val5);
39348 if (!SWIG_IsOK(ecode5)) {
39349 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39350 }
39351 arg5 = static_cast< wxItemKind >(val5);
39352 }
39353 {
39354 PyThreadState* __tstate = wxPyBeginAllowThreads();
39355 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39356 wxPyEndAllowThreads(__tstate);
39357 if (PyErr_Occurred()) SWIG_fail;
39358 }
39359 {
39360 resultobj = wxPyMake_wxObject(result, (bool)0);
39361 }
39362 {
39363 if (temp3)
39364 delete arg3;
39365 }
39366 {
39367 if (temp4)
39368 delete arg4;
39369 }
39370 return resultobj;
39371 fail:
39372 {
39373 if (temp3)
39374 delete arg3;
39375 }
39376 {
39377 if (temp4)
39378 delete arg4;
39379 }
39380 return NULL;
39381 }
39382
39383
39384 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39385 PyObject *resultobj = 0;
39386 wxMenu *arg1 = (wxMenu *) 0 ;
39387 wxMenuItem *result = 0 ;
39388 void *argp1 = 0 ;
39389 int res1 = 0 ;
39390 PyObject *swig_obj[1] ;
39391
39392 if (!args) SWIG_fail;
39393 swig_obj[0] = args;
39394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39395 if (!SWIG_IsOK(res1)) {
39396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39397 }
39398 arg1 = reinterpret_cast< wxMenu * >(argp1);
39399 {
39400 PyThreadState* __tstate = wxPyBeginAllowThreads();
39401 result = (wxMenuItem *)(arg1)->PrependSeparator();
39402 wxPyEndAllowThreads(__tstate);
39403 if (PyErr_Occurred()) SWIG_fail;
39404 }
39405 {
39406 resultobj = wxPyMake_wxObject(result, (bool)0);
39407 }
39408 return resultobj;
39409 fail:
39410 return NULL;
39411 }
39412
39413
39414 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39415 PyObject *resultobj = 0;
39416 wxMenu *arg1 = (wxMenu *) 0 ;
39417 int arg2 ;
39418 wxString *arg3 = 0 ;
39419 wxString const &arg4_defvalue = wxPyEmptyString ;
39420 wxString *arg4 = (wxString *) &arg4_defvalue ;
39421 wxMenuItem *result = 0 ;
39422 void *argp1 = 0 ;
39423 int res1 = 0 ;
39424 int val2 ;
39425 int ecode2 = 0 ;
39426 bool temp3 = false ;
39427 bool temp4 = false ;
39428 PyObject * obj0 = 0 ;
39429 PyObject * obj1 = 0 ;
39430 PyObject * obj2 = 0 ;
39431 PyObject * obj3 = 0 ;
39432 char * kwnames[] = {
39433 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39434 };
39435
39436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39438 if (!SWIG_IsOK(res1)) {
39439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39440 }
39441 arg1 = reinterpret_cast< wxMenu * >(argp1);
39442 ecode2 = SWIG_AsVal_int(obj1, &val2);
39443 if (!SWIG_IsOK(ecode2)) {
39444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39445 }
39446 arg2 = static_cast< int >(val2);
39447 {
39448 arg3 = wxString_in_helper(obj2);
39449 if (arg3 == NULL) SWIG_fail;
39450 temp3 = true;
39451 }
39452 if (obj3) {
39453 {
39454 arg4 = wxString_in_helper(obj3);
39455 if (arg4 == NULL) SWIG_fail;
39456 temp4 = true;
39457 }
39458 }
39459 {
39460 PyThreadState* __tstate = wxPyBeginAllowThreads();
39461 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39462 wxPyEndAllowThreads(__tstate);
39463 if (PyErr_Occurred()) SWIG_fail;
39464 }
39465 {
39466 resultobj = wxPyMake_wxObject(result, (bool)0);
39467 }
39468 {
39469 if (temp3)
39470 delete arg3;
39471 }
39472 {
39473 if (temp4)
39474 delete arg4;
39475 }
39476 return resultobj;
39477 fail:
39478 {
39479 if (temp3)
39480 delete arg3;
39481 }
39482 {
39483 if (temp4)
39484 delete arg4;
39485 }
39486 return NULL;
39487 }
39488
39489
39490 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39491 PyObject *resultobj = 0;
39492 wxMenu *arg1 = (wxMenu *) 0 ;
39493 int arg2 ;
39494 wxString *arg3 = 0 ;
39495 wxString const &arg4_defvalue = wxPyEmptyString ;
39496 wxString *arg4 = (wxString *) &arg4_defvalue ;
39497 wxMenuItem *result = 0 ;
39498 void *argp1 = 0 ;
39499 int res1 = 0 ;
39500 int val2 ;
39501 int ecode2 = 0 ;
39502 bool temp3 = false ;
39503 bool temp4 = false ;
39504 PyObject * obj0 = 0 ;
39505 PyObject * obj1 = 0 ;
39506 PyObject * obj2 = 0 ;
39507 PyObject * obj3 = 0 ;
39508 char * kwnames[] = {
39509 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39510 };
39511
39512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39514 if (!SWIG_IsOK(res1)) {
39515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39516 }
39517 arg1 = reinterpret_cast< wxMenu * >(argp1);
39518 ecode2 = SWIG_AsVal_int(obj1, &val2);
39519 if (!SWIG_IsOK(ecode2)) {
39520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39521 }
39522 arg2 = static_cast< int >(val2);
39523 {
39524 arg3 = wxString_in_helper(obj2);
39525 if (arg3 == NULL) SWIG_fail;
39526 temp3 = true;
39527 }
39528 if (obj3) {
39529 {
39530 arg4 = wxString_in_helper(obj3);
39531 if (arg4 == NULL) SWIG_fail;
39532 temp4 = true;
39533 }
39534 }
39535 {
39536 PyThreadState* __tstate = wxPyBeginAllowThreads();
39537 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39538 wxPyEndAllowThreads(__tstate);
39539 if (PyErr_Occurred()) SWIG_fail;
39540 }
39541 {
39542 resultobj = wxPyMake_wxObject(result, (bool)0);
39543 }
39544 {
39545 if (temp3)
39546 delete arg3;
39547 }
39548 {
39549 if (temp4)
39550 delete arg4;
39551 }
39552 return resultobj;
39553 fail:
39554 {
39555 if (temp3)
39556 delete arg3;
39557 }
39558 {
39559 if (temp4)
39560 delete arg4;
39561 }
39562 return NULL;
39563 }
39564
39565
39566 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39567 PyObject *resultobj = 0;
39568 wxMenu *arg1 = (wxMenu *) 0 ;
39569 int arg2 ;
39570 wxString *arg3 = 0 ;
39571 wxMenu *arg4 = (wxMenu *) 0 ;
39572 wxString const &arg5_defvalue = wxPyEmptyString ;
39573 wxString *arg5 = (wxString *) &arg5_defvalue ;
39574 wxMenuItem *result = 0 ;
39575 void *argp1 = 0 ;
39576 int res1 = 0 ;
39577 int val2 ;
39578 int ecode2 = 0 ;
39579 bool temp3 = false ;
39580 void *argp4 = 0 ;
39581 int res4 = 0 ;
39582 bool temp5 = false ;
39583 PyObject * obj0 = 0 ;
39584 PyObject * obj1 = 0 ;
39585 PyObject * obj2 = 0 ;
39586 PyObject * obj3 = 0 ;
39587 PyObject * obj4 = 0 ;
39588 char * kwnames[] = {
39589 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39590 };
39591
39592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39594 if (!SWIG_IsOK(res1)) {
39595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39596 }
39597 arg1 = reinterpret_cast< wxMenu * >(argp1);
39598 ecode2 = SWIG_AsVal_int(obj1, &val2);
39599 if (!SWIG_IsOK(ecode2)) {
39600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39601 }
39602 arg2 = static_cast< int >(val2);
39603 {
39604 arg3 = wxString_in_helper(obj2);
39605 if (arg3 == NULL) SWIG_fail;
39606 temp3 = true;
39607 }
39608 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39609 if (!SWIG_IsOK(res4)) {
39610 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39611 }
39612 arg4 = reinterpret_cast< wxMenu * >(argp4);
39613 if (obj4) {
39614 {
39615 arg5 = wxString_in_helper(obj4);
39616 if (arg5 == NULL) SWIG_fail;
39617 temp5 = true;
39618 }
39619 }
39620 {
39621 PyThreadState* __tstate = wxPyBeginAllowThreads();
39622 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39623 wxPyEndAllowThreads(__tstate);
39624 if (PyErr_Occurred()) SWIG_fail;
39625 }
39626 {
39627 resultobj = wxPyMake_wxObject(result, (bool)0);
39628 }
39629 {
39630 if (temp3)
39631 delete arg3;
39632 }
39633 {
39634 if (temp5)
39635 delete arg5;
39636 }
39637 return resultobj;
39638 fail:
39639 {
39640 if (temp3)
39641 delete arg3;
39642 }
39643 {
39644 if (temp5)
39645 delete arg5;
39646 }
39647 return NULL;
39648 }
39649
39650
39651 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39652 PyObject *resultobj = 0;
39653 wxMenu *arg1 = (wxMenu *) 0 ;
39654 int arg2 ;
39655 wxMenuItem *result = 0 ;
39656 void *argp1 = 0 ;
39657 int res1 = 0 ;
39658 int val2 ;
39659 int ecode2 = 0 ;
39660 PyObject * obj0 = 0 ;
39661 PyObject * obj1 = 0 ;
39662 char * kwnames[] = {
39663 (char *) "self",(char *) "id", NULL
39664 };
39665
39666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39668 if (!SWIG_IsOK(res1)) {
39669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39670 }
39671 arg1 = reinterpret_cast< wxMenu * >(argp1);
39672 ecode2 = SWIG_AsVal_int(obj1, &val2);
39673 if (!SWIG_IsOK(ecode2)) {
39674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39675 }
39676 arg2 = static_cast< int >(val2);
39677 {
39678 PyThreadState* __tstate = wxPyBeginAllowThreads();
39679 result = (wxMenuItem *)(arg1)->Remove(arg2);
39680 wxPyEndAllowThreads(__tstate);
39681 if (PyErr_Occurred()) SWIG_fail;
39682 }
39683 {
39684 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39685 }
39686 return resultobj;
39687 fail:
39688 return NULL;
39689 }
39690
39691
39692 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39693 PyObject *resultobj = 0;
39694 wxMenu *arg1 = (wxMenu *) 0 ;
39695 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39696 wxMenuItem *result = 0 ;
39697 void *argp1 = 0 ;
39698 int res1 = 0 ;
39699 void *argp2 = 0 ;
39700 int res2 = 0 ;
39701 PyObject * obj0 = 0 ;
39702 PyObject * obj1 = 0 ;
39703 char * kwnames[] = {
39704 (char *) "self",(char *) "item", NULL
39705 };
39706
39707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39709 if (!SWIG_IsOK(res1)) {
39710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39711 }
39712 arg1 = reinterpret_cast< wxMenu * >(argp1);
39713 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39714 if (!SWIG_IsOK(res2)) {
39715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39716 }
39717 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39718 {
39719 PyThreadState* __tstate = wxPyBeginAllowThreads();
39720 result = (wxMenuItem *)(arg1)->Remove(arg2);
39721 wxPyEndAllowThreads(__tstate);
39722 if (PyErr_Occurred()) SWIG_fail;
39723 }
39724 {
39725 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39726 }
39727 return resultobj;
39728 fail:
39729 return NULL;
39730 }
39731
39732
39733 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39734 PyObject *resultobj = 0;
39735 wxMenu *arg1 = (wxMenu *) 0 ;
39736 int arg2 ;
39737 bool result;
39738 void *argp1 = 0 ;
39739 int res1 = 0 ;
39740 int val2 ;
39741 int ecode2 = 0 ;
39742 PyObject * obj0 = 0 ;
39743 PyObject * obj1 = 0 ;
39744 char * kwnames[] = {
39745 (char *) "self",(char *) "id", NULL
39746 };
39747
39748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39750 if (!SWIG_IsOK(res1)) {
39751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39752 }
39753 arg1 = reinterpret_cast< wxMenu * >(argp1);
39754 ecode2 = SWIG_AsVal_int(obj1, &val2);
39755 if (!SWIG_IsOK(ecode2)) {
39756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39757 }
39758 arg2 = static_cast< int >(val2);
39759 {
39760 PyThreadState* __tstate = wxPyBeginAllowThreads();
39761 result = (bool)(arg1)->Delete(arg2);
39762 wxPyEndAllowThreads(__tstate);
39763 if (PyErr_Occurred()) SWIG_fail;
39764 }
39765 {
39766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39767 }
39768 return resultobj;
39769 fail:
39770 return NULL;
39771 }
39772
39773
39774 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39775 PyObject *resultobj = 0;
39776 wxMenu *arg1 = (wxMenu *) 0 ;
39777 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39778 bool result;
39779 void *argp1 = 0 ;
39780 int res1 = 0 ;
39781 void *argp2 = 0 ;
39782 int res2 = 0 ;
39783 PyObject * obj0 = 0 ;
39784 PyObject * obj1 = 0 ;
39785 char * kwnames[] = {
39786 (char *) "self",(char *) "item", NULL
39787 };
39788
39789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39791 if (!SWIG_IsOK(res1)) {
39792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39793 }
39794 arg1 = reinterpret_cast< wxMenu * >(argp1);
39795 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39796 if (!SWIG_IsOK(res2)) {
39797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39798 }
39799 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39800 {
39801 PyThreadState* __tstate = wxPyBeginAllowThreads();
39802 result = (bool)(arg1)->Delete(arg2);
39803 wxPyEndAllowThreads(__tstate);
39804 if (PyErr_Occurred()) SWIG_fail;
39805 }
39806 {
39807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39808 }
39809 return resultobj;
39810 fail:
39811 return NULL;
39812 }
39813
39814
39815 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39816 PyObject *resultobj = 0;
39817 wxMenu *arg1 = (wxMenu *) 0 ;
39818 void *argp1 = 0 ;
39819 int res1 = 0 ;
39820 PyObject *swig_obj[1] ;
39821
39822 if (!args) SWIG_fail;
39823 swig_obj[0] = args;
39824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39825 if (!SWIG_IsOK(res1)) {
39826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39827 }
39828 arg1 = reinterpret_cast< wxMenu * >(argp1);
39829 {
39830 PyThreadState* __tstate = wxPyBeginAllowThreads();
39831 wxMenu_Destroy(arg1);
39832 wxPyEndAllowThreads(__tstate);
39833 if (PyErr_Occurred()) SWIG_fail;
39834 }
39835 resultobj = SWIG_Py_Void();
39836 return resultobj;
39837 fail:
39838 return NULL;
39839 }
39840
39841
39842 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39843 PyObject *resultobj = 0;
39844 wxMenu *arg1 = (wxMenu *) 0 ;
39845 int arg2 ;
39846 bool result;
39847 void *argp1 = 0 ;
39848 int res1 = 0 ;
39849 int val2 ;
39850 int ecode2 = 0 ;
39851 PyObject * obj0 = 0 ;
39852 PyObject * obj1 = 0 ;
39853 char * kwnames[] = {
39854 (char *) "self",(char *) "id", NULL
39855 };
39856
39857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39859 if (!SWIG_IsOK(res1)) {
39860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39861 }
39862 arg1 = reinterpret_cast< wxMenu * >(argp1);
39863 ecode2 = SWIG_AsVal_int(obj1, &val2);
39864 if (!SWIG_IsOK(ecode2)) {
39865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39866 }
39867 arg2 = static_cast< int >(val2);
39868 {
39869 PyThreadState* __tstate = wxPyBeginAllowThreads();
39870 result = (bool)(arg1)->Destroy(arg2);
39871 wxPyEndAllowThreads(__tstate);
39872 if (PyErr_Occurred()) SWIG_fail;
39873 }
39874 {
39875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39876 }
39877 return resultobj;
39878 fail:
39879 return NULL;
39880 }
39881
39882
39883 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39884 PyObject *resultobj = 0;
39885 wxMenu *arg1 = (wxMenu *) 0 ;
39886 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39887 bool result;
39888 void *argp1 = 0 ;
39889 int res1 = 0 ;
39890 void *argp2 = 0 ;
39891 int res2 = 0 ;
39892 PyObject * obj0 = 0 ;
39893 PyObject * obj1 = 0 ;
39894 char * kwnames[] = {
39895 (char *) "self",(char *) "item", NULL
39896 };
39897
39898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39900 if (!SWIG_IsOK(res1)) {
39901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39902 }
39903 arg1 = reinterpret_cast< wxMenu * >(argp1);
39904 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39905 if (!SWIG_IsOK(res2)) {
39906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39907 }
39908 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39909 {
39910 PyThreadState* __tstate = wxPyBeginAllowThreads();
39911 result = (bool)(arg1)->Destroy(arg2);
39912 wxPyEndAllowThreads(__tstate);
39913 if (PyErr_Occurred()) SWIG_fail;
39914 }
39915 {
39916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39917 }
39918 return resultobj;
39919 fail:
39920 return NULL;
39921 }
39922
39923
39924 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39925 PyObject *resultobj = 0;
39926 wxMenu *arg1 = (wxMenu *) 0 ;
39927 size_t result;
39928 void *argp1 = 0 ;
39929 int res1 = 0 ;
39930 PyObject *swig_obj[1] ;
39931
39932 if (!args) SWIG_fail;
39933 swig_obj[0] = args;
39934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39935 if (!SWIG_IsOK(res1)) {
39936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39937 }
39938 arg1 = reinterpret_cast< wxMenu * >(argp1);
39939 {
39940 PyThreadState* __tstate = wxPyBeginAllowThreads();
39941 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39942 wxPyEndAllowThreads(__tstate);
39943 if (PyErr_Occurred()) SWIG_fail;
39944 }
39945 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39946 return resultobj;
39947 fail:
39948 return NULL;
39949 }
39950
39951
39952 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39953 PyObject *resultobj = 0;
39954 wxMenu *arg1 = (wxMenu *) 0 ;
39955 PyObject *result = 0 ;
39956 void *argp1 = 0 ;
39957 int res1 = 0 ;
39958 PyObject *swig_obj[1] ;
39959
39960 if (!args) SWIG_fail;
39961 swig_obj[0] = args;
39962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39963 if (!SWIG_IsOK(res1)) {
39964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39965 }
39966 arg1 = reinterpret_cast< wxMenu * >(argp1);
39967 {
39968 PyThreadState* __tstate = wxPyBeginAllowThreads();
39969 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39970 wxPyEndAllowThreads(__tstate);
39971 if (PyErr_Occurred()) SWIG_fail;
39972 }
39973 resultobj = result;
39974 return resultobj;
39975 fail:
39976 return NULL;
39977 }
39978
39979
39980 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39981 PyObject *resultobj = 0;
39982 wxMenu *arg1 = (wxMenu *) 0 ;
39983 wxString *arg2 = 0 ;
39984 int result;
39985 void *argp1 = 0 ;
39986 int res1 = 0 ;
39987 bool temp2 = false ;
39988 PyObject * obj0 = 0 ;
39989 PyObject * obj1 = 0 ;
39990 char * kwnames[] = {
39991 (char *) "self",(char *) "item", NULL
39992 };
39993
39994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39996 if (!SWIG_IsOK(res1)) {
39997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39998 }
39999 arg1 = reinterpret_cast< wxMenu * >(argp1);
40000 {
40001 arg2 = wxString_in_helper(obj1);
40002 if (arg2 == NULL) SWIG_fail;
40003 temp2 = true;
40004 }
40005 {
40006 PyThreadState* __tstate = wxPyBeginAllowThreads();
40007 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40008 wxPyEndAllowThreads(__tstate);
40009 if (PyErr_Occurred()) SWIG_fail;
40010 }
40011 resultobj = SWIG_From_int(static_cast< int >(result));
40012 {
40013 if (temp2)
40014 delete arg2;
40015 }
40016 return resultobj;
40017 fail:
40018 {
40019 if (temp2)
40020 delete arg2;
40021 }
40022 return NULL;
40023 }
40024
40025
40026 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40027 PyObject *resultobj = 0;
40028 wxMenu *arg1 = (wxMenu *) 0 ;
40029 int arg2 ;
40030 wxMenuItem *result = 0 ;
40031 void *argp1 = 0 ;
40032 int res1 = 0 ;
40033 int val2 ;
40034 int ecode2 = 0 ;
40035 PyObject * obj0 = 0 ;
40036 PyObject * obj1 = 0 ;
40037 char * kwnames[] = {
40038 (char *) "self",(char *) "id", NULL
40039 };
40040
40041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40043 if (!SWIG_IsOK(res1)) {
40044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40045 }
40046 arg1 = reinterpret_cast< wxMenu * >(argp1);
40047 ecode2 = SWIG_AsVal_int(obj1, &val2);
40048 if (!SWIG_IsOK(ecode2)) {
40049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40050 }
40051 arg2 = static_cast< int >(val2);
40052 {
40053 PyThreadState* __tstate = wxPyBeginAllowThreads();
40054 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40055 wxPyEndAllowThreads(__tstate);
40056 if (PyErr_Occurred()) SWIG_fail;
40057 }
40058 {
40059 resultobj = wxPyMake_wxObject(result, (bool)0);
40060 }
40061 return resultobj;
40062 fail:
40063 return NULL;
40064 }
40065
40066
40067 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40068 PyObject *resultobj = 0;
40069 wxMenu *arg1 = (wxMenu *) 0 ;
40070 size_t arg2 ;
40071 wxMenuItem *result = 0 ;
40072 void *argp1 = 0 ;
40073 int res1 = 0 ;
40074 size_t val2 ;
40075 int ecode2 = 0 ;
40076 PyObject * obj0 = 0 ;
40077 PyObject * obj1 = 0 ;
40078 char * kwnames[] = {
40079 (char *) "self",(char *) "position", NULL
40080 };
40081
40082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40084 if (!SWIG_IsOK(res1)) {
40085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40086 }
40087 arg1 = reinterpret_cast< wxMenu * >(argp1);
40088 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40089 if (!SWIG_IsOK(ecode2)) {
40090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40091 }
40092 arg2 = static_cast< size_t >(val2);
40093 {
40094 PyThreadState* __tstate = wxPyBeginAllowThreads();
40095 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40096 wxPyEndAllowThreads(__tstate);
40097 if (PyErr_Occurred()) SWIG_fail;
40098 }
40099 {
40100 resultobj = wxPyMake_wxObject(result, (bool)0);
40101 }
40102 return resultobj;
40103 fail:
40104 return NULL;
40105 }
40106
40107
40108 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40109 PyObject *resultobj = 0;
40110 wxMenu *arg1 = (wxMenu *) 0 ;
40111 int arg2 ;
40112 bool arg3 ;
40113 void *argp1 = 0 ;
40114 int res1 = 0 ;
40115 int val2 ;
40116 int ecode2 = 0 ;
40117 bool val3 ;
40118 int ecode3 = 0 ;
40119 PyObject * obj0 = 0 ;
40120 PyObject * obj1 = 0 ;
40121 PyObject * obj2 = 0 ;
40122 char * kwnames[] = {
40123 (char *) "self",(char *) "id",(char *) "enable", NULL
40124 };
40125
40126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40128 if (!SWIG_IsOK(res1)) {
40129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40130 }
40131 arg1 = reinterpret_cast< wxMenu * >(argp1);
40132 ecode2 = SWIG_AsVal_int(obj1, &val2);
40133 if (!SWIG_IsOK(ecode2)) {
40134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40135 }
40136 arg2 = static_cast< int >(val2);
40137 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40138 if (!SWIG_IsOK(ecode3)) {
40139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40140 }
40141 arg3 = static_cast< bool >(val3);
40142 {
40143 PyThreadState* __tstate = wxPyBeginAllowThreads();
40144 (arg1)->Enable(arg2,arg3);
40145 wxPyEndAllowThreads(__tstate);
40146 if (PyErr_Occurred()) SWIG_fail;
40147 }
40148 resultobj = SWIG_Py_Void();
40149 return resultobj;
40150 fail:
40151 return NULL;
40152 }
40153
40154
40155 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40156 PyObject *resultobj = 0;
40157 wxMenu *arg1 = (wxMenu *) 0 ;
40158 int arg2 ;
40159 bool result;
40160 void *argp1 = 0 ;
40161 int res1 = 0 ;
40162 int val2 ;
40163 int ecode2 = 0 ;
40164 PyObject * obj0 = 0 ;
40165 PyObject * obj1 = 0 ;
40166 char * kwnames[] = {
40167 (char *) "self",(char *) "id", NULL
40168 };
40169
40170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40172 if (!SWIG_IsOK(res1)) {
40173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40174 }
40175 arg1 = reinterpret_cast< wxMenu * >(argp1);
40176 ecode2 = SWIG_AsVal_int(obj1, &val2);
40177 if (!SWIG_IsOK(ecode2)) {
40178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40179 }
40180 arg2 = static_cast< int >(val2);
40181 {
40182 PyThreadState* __tstate = wxPyBeginAllowThreads();
40183 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40184 wxPyEndAllowThreads(__tstate);
40185 if (PyErr_Occurred()) SWIG_fail;
40186 }
40187 {
40188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40189 }
40190 return resultobj;
40191 fail:
40192 return NULL;
40193 }
40194
40195
40196 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40197 PyObject *resultobj = 0;
40198 wxMenu *arg1 = (wxMenu *) 0 ;
40199 int arg2 ;
40200 bool arg3 ;
40201 void *argp1 = 0 ;
40202 int res1 = 0 ;
40203 int val2 ;
40204 int ecode2 = 0 ;
40205 bool val3 ;
40206 int ecode3 = 0 ;
40207 PyObject * obj0 = 0 ;
40208 PyObject * obj1 = 0 ;
40209 PyObject * obj2 = 0 ;
40210 char * kwnames[] = {
40211 (char *) "self",(char *) "id",(char *) "check", NULL
40212 };
40213
40214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40216 if (!SWIG_IsOK(res1)) {
40217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40218 }
40219 arg1 = reinterpret_cast< wxMenu * >(argp1);
40220 ecode2 = SWIG_AsVal_int(obj1, &val2);
40221 if (!SWIG_IsOK(ecode2)) {
40222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40223 }
40224 arg2 = static_cast< int >(val2);
40225 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40226 if (!SWIG_IsOK(ecode3)) {
40227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40228 }
40229 arg3 = static_cast< bool >(val3);
40230 {
40231 PyThreadState* __tstate = wxPyBeginAllowThreads();
40232 (arg1)->Check(arg2,arg3);
40233 wxPyEndAllowThreads(__tstate);
40234 if (PyErr_Occurred()) SWIG_fail;
40235 }
40236 resultobj = SWIG_Py_Void();
40237 return resultobj;
40238 fail:
40239 return NULL;
40240 }
40241
40242
40243 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40244 PyObject *resultobj = 0;
40245 wxMenu *arg1 = (wxMenu *) 0 ;
40246 int arg2 ;
40247 bool result;
40248 void *argp1 = 0 ;
40249 int res1 = 0 ;
40250 int val2 ;
40251 int ecode2 = 0 ;
40252 PyObject * obj0 = 0 ;
40253 PyObject * obj1 = 0 ;
40254 char * kwnames[] = {
40255 (char *) "self",(char *) "id", NULL
40256 };
40257
40258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40260 if (!SWIG_IsOK(res1)) {
40261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40262 }
40263 arg1 = reinterpret_cast< wxMenu * >(argp1);
40264 ecode2 = SWIG_AsVal_int(obj1, &val2);
40265 if (!SWIG_IsOK(ecode2)) {
40266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40267 }
40268 arg2 = static_cast< int >(val2);
40269 {
40270 PyThreadState* __tstate = wxPyBeginAllowThreads();
40271 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40272 wxPyEndAllowThreads(__tstate);
40273 if (PyErr_Occurred()) SWIG_fail;
40274 }
40275 {
40276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40277 }
40278 return resultobj;
40279 fail:
40280 return NULL;
40281 }
40282
40283
40284 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40285 PyObject *resultobj = 0;
40286 wxMenu *arg1 = (wxMenu *) 0 ;
40287 int arg2 ;
40288 wxString *arg3 = 0 ;
40289 void *argp1 = 0 ;
40290 int res1 = 0 ;
40291 int val2 ;
40292 int ecode2 = 0 ;
40293 bool temp3 = false ;
40294 PyObject * obj0 = 0 ;
40295 PyObject * obj1 = 0 ;
40296 PyObject * obj2 = 0 ;
40297 char * kwnames[] = {
40298 (char *) "self",(char *) "id",(char *) "label", NULL
40299 };
40300
40301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40303 if (!SWIG_IsOK(res1)) {
40304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40305 }
40306 arg1 = reinterpret_cast< wxMenu * >(argp1);
40307 ecode2 = SWIG_AsVal_int(obj1, &val2);
40308 if (!SWIG_IsOK(ecode2)) {
40309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40310 }
40311 arg2 = static_cast< int >(val2);
40312 {
40313 arg3 = wxString_in_helper(obj2);
40314 if (arg3 == NULL) SWIG_fail;
40315 temp3 = true;
40316 }
40317 {
40318 PyThreadState* __tstate = wxPyBeginAllowThreads();
40319 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40320 wxPyEndAllowThreads(__tstate);
40321 if (PyErr_Occurred()) SWIG_fail;
40322 }
40323 resultobj = SWIG_Py_Void();
40324 {
40325 if (temp3)
40326 delete arg3;
40327 }
40328 return resultobj;
40329 fail:
40330 {
40331 if (temp3)
40332 delete arg3;
40333 }
40334 return NULL;
40335 }
40336
40337
40338 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40339 PyObject *resultobj = 0;
40340 wxMenu *arg1 = (wxMenu *) 0 ;
40341 int arg2 ;
40342 wxString result;
40343 void *argp1 = 0 ;
40344 int res1 = 0 ;
40345 int val2 ;
40346 int ecode2 = 0 ;
40347 PyObject * obj0 = 0 ;
40348 PyObject * obj1 = 0 ;
40349 char * kwnames[] = {
40350 (char *) "self",(char *) "id", NULL
40351 };
40352
40353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40355 if (!SWIG_IsOK(res1)) {
40356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40357 }
40358 arg1 = reinterpret_cast< wxMenu * >(argp1);
40359 ecode2 = SWIG_AsVal_int(obj1, &val2);
40360 if (!SWIG_IsOK(ecode2)) {
40361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40362 }
40363 arg2 = static_cast< int >(val2);
40364 {
40365 PyThreadState* __tstate = wxPyBeginAllowThreads();
40366 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40367 wxPyEndAllowThreads(__tstate);
40368 if (PyErr_Occurred()) SWIG_fail;
40369 }
40370 {
40371 #if wxUSE_UNICODE
40372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40373 #else
40374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40375 #endif
40376 }
40377 return resultobj;
40378 fail:
40379 return NULL;
40380 }
40381
40382
40383 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40384 PyObject *resultobj = 0;
40385 wxMenu *arg1 = (wxMenu *) 0 ;
40386 int arg2 ;
40387 wxString *arg3 = 0 ;
40388 void *argp1 = 0 ;
40389 int res1 = 0 ;
40390 int val2 ;
40391 int ecode2 = 0 ;
40392 bool temp3 = false ;
40393 PyObject * obj0 = 0 ;
40394 PyObject * obj1 = 0 ;
40395 PyObject * obj2 = 0 ;
40396 char * kwnames[] = {
40397 (char *) "self",(char *) "id",(char *) "helpString", NULL
40398 };
40399
40400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40402 if (!SWIG_IsOK(res1)) {
40403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40404 }
40405 arg1 = reinterpret_cast< wxMenu * >(argp1);
40406 ecode2 = SWIG_AsVal_int(obj1, &val2);
40407 if (!SWIG_IsOK(ecode2)) {
40408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40409 }
40410 arg2 = static_cast< int >(val2);
40411 {
40412 arg3 = wxString_in_helper(obj2);
40413 if (arg3 == NULL) SWIG_fail;
40414 temp3 = true;
40415 }
40416 {
40417 PyThreadState* __tstate = wxPyBeginAllowThreads();
40418 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40419 wxPyEndAllowThreads(__tstate);
40420 if (PyErr_Occurred()) SWIG_fail;
40421 }
40422 resultobj = SWIG_Py_Void();
40423 {
40424 if (temp3)
40425 delete arg3;
40426 }
40427 return resultobj;
40428 fail:
40429 {
40430 if (temp3)
40431 delete arg3;
40432 }
40433 return NULL;
40434 }
40435
40436
40437 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40438 PyObject *resultobj = 0;
40439 wxMenu *arg1 = (wxMenu *) 0 ;
40440 int arg2 ;
40441 wxString result;
40442 void *argp1 = 0 ;
40443 int res1 = 0 ;
40444 int val2 ;
40445 int ecode2 = 0 ;
40446 PyObject * obj0 = 0 ;
40447 PyObject * obj1 = 0 ;
40448 char * kwnames[] = {
40449 (char *) "self",(char *) "id", NULL
40450 };
40451
40452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40454 if (!SWIG_IsOK(res1)) {
40455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40456 }
40457 arg1 = reinterpret_cast< wxMenu * >(argp1);
40458 ecode2 = SWIG_AsVal_int(obj1, &val2);
40459 if (!SWIG_IsOK(ecode2)) {
40460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40461 }
40462 arg2 = static_cast< int >(val2);
40463 {
40464 PyThreadState* __tstate = wxPyBeginAllowThreads();
40465 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40466 wxPyEndAllowThreads(__tstate);
40467 if (PyErr_Occurred()) SWIG_fail;
40468 }
40469 {
40470 #if wxUSE_UNICODE
40471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40472 #else
40473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40474 #endif
40475 }
40476 return resultobj;
40477 fail:
40478 return NULL;
40479 }
40480
40481
40482 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40483 PyObject *resultobj = 0;
40484 wxMenu *arg1 = (wxMenu *) 0 ;
40485 wxString *arg2 = 0 ;
40486 void *argp1 = 0 ;
40487 int res1 = 0 ;
40488 bool temp2 = false ;
40489 PyObject * obj0 = 0 ;
40490 PyObject * obj1 = 0 ;
40491 char * kwnames[] = {
40492 (char *) "self",(char *) "title", NULL
40493 };
40494
40495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40497 if (!SWIG_IsOK(res1)) {
40498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40499 }
40500 arg1 = reinterpret_cast< wxMenu * >(argp1);
40501 {
40502 arg2 = wxString_in_helper(obj1);
40503 if (arg2 == NULL) SWIG_fail;
40504 temp2 = true;
40505 }
40506 {
40507 PyThreadState* __tstate = wxPyBeginAllowThreads();
40508 (arg1)->SetTitle((wxString const &)*arg2);
40509 wxPyEndAllowThreads(__tstate);
40510 if (PyErr_Occurred()) SWIG_fail;
40511 }
40512 resultobj = SWIG_Py_Void();
40513 {
40514 if (temp2)
40515 delete arg2;
40516 }
40517 return resultobj;
40518 fail:
40519 {
40520 if (temp2)
40521 delete arg2;
40522 }
40523 return NULL;
40524 }
40525
40526
40527 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40528 PyObject *resultobj = 0;
40529 wxMenu *arg1 = (wxMenu *) 0 ;
40530 wxString result;
40531 void *argp1 = 0 ;
40532 int res1 = 0 ;
40533 PyObject *swig_obj[1] ;
40534
40535 if (!args) SWIG_fail;
40536 swig_obj[0] = args;
40537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40538 if (!SWIG_IsOK(res1)) {
40539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40540 }
40541 arg1 = reinterpret_cast< wxMenu * >(argp1);
40542 {
40543 PyThreadState* __tstate = wxPyBeginAllowThreads();
40544 result = ((wxMenu const *)arg1)->GetTitle();
40545 wxPyEndAllowThreads(__tstate);
40546 if (PyErr_Occurred()) SWIG_fail;
40547 }
40548 {
40549 #if wxUSE_UNICODE
40550 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40551 #else
40552 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40553 #endif
40554 }
40555 return resultobj;
40556 fail:
40557 return NULL;
40558 }
40559
40560
40561 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40562 PyObject *resultobj = 0;
40563 wxMenu *arg1 = (wxMenu *) 0 ;
40564 wxEvtHandler *arg2 = (wxEvtHandler *) 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 *) "handler", NULL
40573 };
40574
40575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",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_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40579 }
40580 arg1 = reinterpret_cast< wxMenu * >(argp1);
40581 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40582 if (!SWIG_IsOK(res2)) {
40583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40584 }
40585 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40586 {
40587 PyThreadState* __tstate = wxPyBeginAllowThreads();
40588 (arg1)->SetEventHandler(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_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40600 PyObject *resultobj = 0;
40601 wxMenu *arg1 = (wxMenu *) 0 ;
40602 wxEvtHandler *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_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40612 }
40613 arg1 = reinterpret_cast< wxMenu * >(argp1);
40614 {
40615 PyThreadState* __tstate = wxPyBeginAllowThreads();
40616 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
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 *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40630 PyObject *resultobj = 0;
40631 wxMenu *arg1 = (wxMenu *) 0 ;
40632 wxWindow *arg2 = (wxWindow *) 0 ;
40633 void *argp1 = 0 ;
40634 int res1 = 0 ;
40635 void *argp2 = 0 ;
40636 int res2 = 0 ;
40637 PyObject * obj0 = 0 ;
40638 PyObject * obj1 = 0 ;
40639 char * kwnames[] = {
40640 (char *) "self",(char *) "win", NULL
40641 };
40642
40643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40645 if (!SWIG_IsOK(res1)) {
40646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40647 }
40648 arg1 = reinterpret_cast< wxMenu * >(argp1);
40649 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40650 if (!SWIG_IsOK(res2)) {
40651 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40652 }
40653 arg2 = reinterpret_cast< wxWindow * >(argp2);
40654 {
40655 PyThreadState* __tstate = wxPyBeginAllowThreads();
40656 (arg1)->SetInvokingWindow(arg2);
40657 wxPyEndAllowThreads(__tstate);
40658 if (PyErr_Occurred()) SWIG_fail;
40659 }
40660 resultobj = SWIG_Py_Void();
40661 return resultobj;
40662 fail:
40663 return NULL;
40664 }
40665
40666
40667 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40668 PyObject *resultobj = 0;
40669 wxMenu *arg1 = (wxMenu *) 0 ;
40670 wxWindow *result = 0 ;
40671 void *argp1 = 0 ;
40672 int res1 = 0 ;
40673 PyObject *swig_obj[1] ;
40674
40675 if (!args) SWIG_fail;
40676 swig_obj[0] = args;
40677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40678 if (!SWIG_IsOK(res1)) {
40679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40680 }
40681 arg1 = reinterpret_cast< wxMenu * >(argp1);
40682 {
40683 PyThreadState* __tstate = wxPyBeginAllowThreads();
40684 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40685 wxPyEndAllowThreads(__tstate);
40686 if (PyErr_Occurred()) SWIG_fail;
40687 }
40688 {
40689 resultobj = wxPyMake_wxObject(result, 0);
40690 }
40691 return resultobj;
40692 fail:
40693 return NULL;
40694 }
40695
40696
40697 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40698 PyObject *resultobj = 0;
40699 wxMenu *arg1 = (wxMenu *) 0 ;
40700 long result;
40701 void *argp1 = 0 ;
40702 int res1 = 0 ;
40703 PyObject *swig_obj[1] ;
40704
40705 if (!args) SWIG_fail;
40706 swig_obj[0] = args;
40707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40708 if (!SWIG_IsOK(res1)) {
40709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40710 }
40711 arg1 = reinterpret_cast< wxMenu * >(argp1);
40712 {
40713 PyThreadState* __tstate = wxPyBeginAllowThreads();
40714 result = (long)((wxMenu const *)arg1)->GetStyle();
40715 wxPyEndAllowThreads(__tstate);
40716 if (PyErr_Occurred()) SWIG_fail;
40717 }
40718 resultobj = SWIG_From_long(static_cast< long >(result));
40719 return resultobj;
40720 fail:
40721 return NULL;
40722 }
40723
40724
40725 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40726 PyObject *resultobj = 0;
40727 wxMenu *arg1 = (wxMenu *) 0 ;
40728 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40729 void *argp1 = 0 ;
40730 int res1 = 0 ;
40731 void *argp2 = 0 ;
40732 int res2 = 0 ;
40733 PyObject * obj0 = 0 ;
40734 PyObject * obj1 = 0 ;
40735 char * kwnames[] = {
40736 (char *) "self",(char *) "source", NULL
40737 };
40738
40739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40741 if (!SWIG_IsOK(res1)) {
40742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40743 }
40744 arg1 = reinterpret_cast< wxMenu * >(argp1);
40745 if (obj1) {
40746 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40747 if (!SWIG_IsOK(res2)) {
40748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40749 }
40750 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40751 }
40752 {
40753 PyThreadState* __tstate = wxPyBeginAllowThreads();
40754 (arg1)->UpdateUI(arg2);
40755 wxPyEndAllowThreads(__tstate);
40756 if (PyErr_Occurred()) SWIG_fail;
40757 }
40758 resultobj = SWIG_Py_Void();
40759 return resultobj;
40760 fail:
40761 return NULL;
40762 }
40763
40764
40765 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40766 PyObject *resultobj = 0;
40767 wxMenu *arg1 = (wxMenu *) 0 ;
40768 wxMenuBar *result = 0 ;
40769 void *argp1 = 0 ;
40770 int res1 = 0 ;
40771 PyObject *swig_obj[1] ;
40772
40773 if (!args) SWIG_fail;
40774 swig_obj[0] = args;
40775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40776 if (!SWIG_IsOK(res1)) {
40777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40778 }
40779 arg1 = reinterpret_cast< wxMenu * >(argp1);
40780 {
40781 PyThreadState* __tstate = wxPyBeginAllowThreads();
40782 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40783 wxPyEndAllowThreads(__tstate);
40784 if (PyErr_Occurred()) SWIG_fail;
40785 }
40786 {
40787 resultobj = wxPyMake_wxObject(result, (bool)0);
40788 }
40789 return resultobj;
40790 fail:
40791 return NULL;
40792 }
40793
40794
40795 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40796 PyObject *resultobj = 0;
40797 wxMenu *arg1 = (wxMenu *) 0 ;
40798 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40799 void *argp1 = 0 ;
40800 int res1 = 0 ;
40801 void *argp2 = 0 ;
40802 int res2 = 0 ;
40803 PyObject * obj0 = 0 ;
40804 PyObject * obj1 = 0 ;
40805 char * kwnames[] = {
40806 (char *) "self",(char *) "menubar", NULL
40807 };
40808
40809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40811 if (!SWIG_IsOK(res1)) {
40812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40813 }
40814 arg1 = reinterpret_cast< wxMenu * >(argp1);
40815 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40816 if (!SWIG_IsOK(res2)) {
40817 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40818 }
40819 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40820 {
40821 PyThreadState* __tstate = wxPyBeginAllowThreads();
40822 (arg1)->Attach(arg2);
40823 wxPyEndAllowThreads(__tstate);
40824 if (PyErr_Occurred()) SWIG_fail;
40825 }
40826 resultobj = SWIG_Py_Void();
40827 return resultobj;
40828 fail:
40829 return NULL;
40830 }
40831
40832
40833 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40834 PyObject *resultobj = 0;
40835 wxMenu *arg1 = (wxMenu *) 0 ;
40836 void *argp1 = 0 ;
40837 int res1 = 0 ;
40838 PyObject *swig_obj[1] ;
40839
40840 if (!args) SWIG_fail;
40841 swig_obj[0] = args;
40842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40843 if (!SWIG_IsOK(res1)) {
40844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40845 }
40846 arg1 = reinterpret_cast< wxMenu * >(argp1);
40847 {
40848 PyThreadState* __tstate = wxPyBeginAllowThreads();
40849 (arg1)->Detach();
40850 wxPyEndAllowThreads(__tstate);
40851 if (PyErr_Occurred()) SWIG_fail;
40852 }
40853 resultobj = SWIG_Py_Void();
40854 return resultobj;
40855 fail:
40856 return NULL;
40857 }
40858
40859
40860 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40861 PyObject *resultobj = 0;
40862 wxMenu *arg1 = (wxMenu *) 0 ;
40863 bool result;
40864 void *argp1 = 0 ;
40865 int res1 = 0 ;
40866 PyObject *swig_obj[1] ;
40867
40868 if (!args) SWIG_fail;
40869 swig_obj[0] = args;
40870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40871 if (!SWIG_IsOK(res1)) {
40872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40873 }
40874 arg1 = reinterpret_cast< wxMenu * >(argp1);
40875 {
40876 PyThreadState* __tstate = wxPyBeginAllowThreads();
40877 result = (bool)((wxMenu const *)arg1)->IsAttached();
40878 wxPyEndAllowThreads(__tstate);
40879 if (PyErr_Occurred()) SWIG_fail;
40880 }
40881 {
40882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40883 }
40884 return resultobj;
40885 fail:
40886 return NULL;
40887 }
40888
40889
40890 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40891 PyObject *resultobj = 0;
40892 wxMenu *arg1 = (wxMenu *) 0 ;
40893 wxMenu *arg2 = (wxMenu *) 0 ;
40894 void *argp1 = 0 ;
40895 int res1 = 0 ;
40896 void *argp2 = 0 ;
40897 int res2 = 0 ;
40898 PyObject * obj0 = 0 ;
40899 PyObject * obj1 = 0 ;
40900 char * kwnames[] = {
40901 (char *) "self",(char *) "parent", NULL
40902 };
40903
40904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40906 if (!SWIG_IsOK(res1)) {
40907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40908 }
40909 arg1 = reinterpret_cast< wxMenu * >(argp1);
40910 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40911 if (!SWIG_IsOK(res2)) {
40912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40913 }
40914 arg2 = reinterpret_cast< wxMenu * >(argp2);
40915 {
40916 PyThreadState* __tstate = wxPyBeginAllowThreads();
40917 (arg1)->SetParent(arg2);
40918 wxPyEndAllowThreads(__tstate);
40919 if (PyErr_Occurred()) SWIG_fail;
40920 }
40921 resultobj = SWIG_Py_Void();
40922 return resultobj;
40923 fail:
40924 return NULL;
40925 }
40926
40927
40928 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40929 PyObject *resultobj = 0;
40930 wxMenu *arg1 = (wxMenu *) 0 ;
40931 wxMenu *result = 0 ;
40932 void *argp1 = 0 ;
40933 int res1 = 0 ;
40934 PyObject *swig_obj[1] ;
40935
40936 if (!args) SWIG_fail;
40937 swig_obj[0] = args;
40938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40939 if (!SWIG_IsOK(res1)) {
40940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40941 }
40942 arg1 = reinterpret_cast< wxMenu * >(argp1);
40943 {
40944 PyThreadState* __tstate = wxPyBeginAllowThreads();
40945 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40946 wxPyEndAllowThreads(__tstate);
40947 if (PyErr_Occurred()) SWIG_fail;
40948 }
40949 {
40950 resultobj = wxPyMake_wxObject(result, 0);
40951 }
40952 return resultobj;
40953 fail:
40954 return NULL;
40955 }
40956
40957
40958 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40959 PyObject *obj;
40960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40961 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40962 return SWIG_Py_Void();
40963 }
40964
40965 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40966 return SWIG_Python_InitShadowInstance(args);
40967 }
40968
40969 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40970 PyObject *resultobj = 0;
40971 long arg1 = (long) 0 ;
40972 wxMenuBar *result = 0 ;
40973 long val1 ;
40974 int ecode1 = 0 ;
40975 PyObject * obj0 = 0 ;
40976 char * kwnames[] = {
40977 (char *) "style", NULL
40978 };
40979
40980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40981 if (obj0) {
40982 ecode1 = SWIG_AsVal_long(obj0, &val1);
40983 if (!SWIG_IsOK(ecode1)) {
40984 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40985 }
40986 arg1 = static_cast< long >(val1);
40987 }
40988 {
40989 if (!wxPyCheckForApp()) SWIG_fail;
40990 PyThreadState* __tstate = wxPyBeginAllowThreads();
40991 result = (wxMenuBar *)new wxMenuBar(arg1);
40992 wxPyEndAllowThreads(__tstate);
40993 if (PyErr_Occurred()) SWIG_fail;
40994 }
40995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40996 return resultobj;
40997 fail:
40998 return NULL;
40999 }
41000
41001
41002 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41003 PyObject *resultobj = 0;
41004 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41005 wxMenu *arg2 = (wxMenu *) 0 ;
41006 wxString *arg3 = 0 ;
41007 bool result;
41008 void *argp1 = 0 ;
41009 int res1 = 0 ;
41010 void *argp2 = 0 ;
41011 int res2 = 0 ;
41012 bool temp3 = false ;
41013 PyObject * obj0 = 0 ;
41014 PyObject * obj1 = 0 ;
41015 PyObject * obj2 = 0 ;
41016 char * kwnames[] = {
41017 (char *) "self",(char *) "menu",(char *) "title", NULL
41018 };
41019
41020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41022 if (!SWIG_IsOK(res1)) {
41023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41024 }
41025 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41026 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41027 if (!SWIG_IsOK(res2)) {
41028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41029 }
41030 arg2 = reinterpret_cast< wxMenu * >(argp2);
41031 {
41032 arg3 = wxString_in_helper(obj2);
41033 if (arg3 == NULL) SWIG_fail;
41034 temp3 = true;
41035 }
41036 {
41037 PyThreadState* __tstate = wxPyBeginAllowThreads();
41038 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41039 wxPyEndAllowThreads(__tstate);
41040 if (PyErr_Occurred()) SWIG_fail;
41041 }
41042 {
41043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41044 }
41045 {
41046 if (temp3)
41047 delete arg3;
41048 }
41049 return resultobj;
41050 fail:
41051 {
41052 if (temp3)
41053 delete arg3;
41054 }
41055 return NULL;
41056 }
41057
41058
41059 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41060 PyObject *resultobj = 0;
41061 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41062 size_t arg2 ;
41063 wxMenu *arg3 = (wxMenu *) 0 ;
41064 wxString *arg4 = 0 ;
41065 bool result;
41066 void *argp1 = 0 ;
41067 int res1 = 0 ;
41068 size_t val2 ;
41069 int ecode2 = 0 ;
41070 void *argp3 = 0 ;
41071 int res3 = 0 ;
41072 bool temp4 = false ;
41073 PyObject * obj0 = 0 ;
41074 PyObject * obj1 = 0 ;
41075 PyObject * obj2 = 0 ;
41076 PyObject * obj3 = 0 ;
41077 char * kwnames[] = {
41078 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41079 };
41080
41081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41083 if (!SWIG_IsOK(res1)) {
41084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41085 }
41086 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41087 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41088 if (!SWIG_IsOK(ecode2)) {
41089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41090 }
41091 arg2 = static_cast< size_t >(val2);
41092 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41093 if (!SWIG_IsOK(res3)) {
41094 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41095 }
41096 arg3 = reinterpret_cast< wxMenu * >(argp3);
41097 {
41098 arg4 = wxString_in_helper(obj3);
41099 if (arg4 == NULL) SWIG_fail;
41100 temp4 = true;
41101 }
41102 {
41103 PyThreadState* __tstate = wxPyBeginAllowThreads();
41104 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41105 wxPyEndAllowThreads(__tstate);
41106 if (PyErr_Occurred()) SWIG_fail;
41107 }
41108 {
41109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41110 }
41111 {
41112 if (temp4)
41113 delete arg4;
41114 }
41115 return resultobj;
41116 fail:
41117 {
41118 if (temp4)
41119 delete arg4;
41120 }
41121 return NULL;
41122 }
41123
41124
41125 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41126 PyObject *resultobj = 0;
41127 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41128 size_t result;
41129 void *argp1 = 0 ;
41130 int res1 = 0 ;
41131 PyObject *swig_obj[1] ;
41132
41133 if (!args) SWIG_fail;
41134 swig_obj[0] = args;
41135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41136 if (!SWIG_IsOK(res1)) {
41137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41138 }
41139 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41140 {
41141 PyThreadState* __tstate = wxPyBeginAllowThreads();
41142 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41143 wxPyEndAllowThreads(__tstate);
41144 if (PyErr_Occurred()) SWIG_fail;
41145 }
41146 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41147 return resultobj;
41148 fail:
41149 return NULL;
41150 }
41151
41152
41153 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41154 PyObject *resultobj = 0;
41155 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41156 size_t arg2 ;
41157 wxMenu *result = 0 ;
41158 void *argp1 = 0 ;
41159 int res1 = 0 ;
41160 size_t val2 ;
41161 int ecode2 = 0 ;
41162 PyObject * obj0 = 0 ;
41163 PyObject * obj1 = 0 ;
41164 char * kwnames[] = {
41165 (char *) "self",(char *) "pos", NULL
41166 };
41167
41168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41170 if (!SWIG_IsOK(res1)) {
41171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41172 }
41173 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41174 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41175 if (!SWIG_IsOK(ecode2)) {
41176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41177 }
41178 arg2 = static_cast< size_t >(val2);
41179 {
41180 PyThreadState* __tstate = wxPyBeginAllowThreads();
41181 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41182 wxPyEndAllowThreads(__tstate);
41183 if (PyErr_Occurred()) SWIG_fail;
41184 }
41185 {
41186 resultobj = wxPyMake_wxObject(result, 0);
41187 }
41188 return resultobj;
41189 fail:
41190 return NULL;
41191 }
41192
41193
41194 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41195 PyObject *resultobj = 0;
41196 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41197 size_t arg2 ;
41198 wxMenu *arg3 = (wxMenu *) 0 ;
41199 wxString *arg4 = 0 ;
41200 wxMenu *result = 0 ;
41201 void *argp1 = 0 ;
41202 int res1 = 0 ;
41203 size_t val2 ;
41204 int ecode2 = 0 ;
41205 void *argp3 = 0 ;
41206 int res3 = 0 ;
41207 bool temp4 = false ;
41208 PyObject * obj0 = 0 ;
41209 PyObject * obj1 = 0 ;
41210 PyObject * obj2 = 0 ;
41211 PyObject * obj3 = 0 ;
41212 char * kwnames[] = {
41213 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41214 };
41215
41216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41218 if (!SWIG_IsOK(res1)) {
41219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41220 }
41221 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41222 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41223 if (!SWIG_IsOK(ecode2)) {
41224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41225 }
41226 arg2 = static_cast< size_t >(val2);
41227 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41228 if (!SWIG_IsOK(res3)) {
41229 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41230 }
41231 arg3 = reinterpret_cast< wxMenu * >(argp3);
41232 {
41233 arg4 = wxString_in_helper(obj3);
41234 if (arg4 == NULL) SWIG_fail;
41235 temp4 = true;
41236 }
41237 {
41238 PyThreadState* __tstate = wxPyBeginAllowThreads();
41239 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41240 wxPyEndAllowThreads(__tstate);
41241 if (PyErr_Occurred()) SWIG_fail;
41242 }
41243 {
41244 resultobj = wxPyMake_wxObject(result, 0);
41245 }
41246 {
41247 if (temp4)
41248 delete arg4;
41249 }
41250 return resultobj;
41251 fail:
41252 {
41253 if (temp4)
41254 delete arg4;
41255 }
41256 return NULL;
41257 }
41258
41259
41260 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41261 PyObject *resultobj = 0;
41262 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41263 size_t arg2 ;
41264 wxMenu *result = 0 ;
41265 void *argp1 = 0 ;
41266 int res1 = 0 ;
41267 size_t val2 ;
41268 int ecode2 = 0 ;
41269 PyObject * obj0 = 0 ;
41270 PyObject * obj1 = 0 ;
41271 char * kwnames[] = {
41272 (char *) "self",(char *) "pos", NULL
41273 };
41274
41275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41277 if (!SWIG_IsOK(res1)) {
41278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41279 }
41280 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41281 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41282 if (!SWIG_IsOK(ecode2)) {
41283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41284 }
41285 arg2 = static_cast< size_t >(val2);
41286 {
41287 PyThreadState* __tstate = wxPyBeginAllowThreads();
41288 result = (wxMenu *)(arg1)->Remove(arg2);
41289 wxPyEndAllowThreads(__tstate);
41290 if (PyErr_Occurred()) SWIG_fail;
41291 }
41292 {
41293 resultobj = wxPyMake_wxObject(result, 0);
41294 }
41295 return resultobj;
41296 fail:
41297 return NULL;
41298 }
41299
41300
41301 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41302 PyObject *resultobj = 0;
41303 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41304 size_t arg2 ;
41305 bool arg3 ;
41306 void *argp1 = 0 ;
41307 int res1 = 0 ;
41308 size_t val2 ;
41309 int ecode2 = 0 ;
41310 bool val3 ;
41311 int ecode3 = 0 ;
41312 PyObject * obj0 = 0 ;
41313 PyObject * obj1 = 0 ;
41314 PyObject * obj2 = 0 ;
41315 char * kwnames[] = {
41316 (char *) "self",(char *) "pos",(char *) "enable", NULL
41317 };
41318
41319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41321 if (!SWIG_IsOK(res1)) {
41322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41323 }
41324 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41325 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41326 if (!SWIG_IsOK(ecode2)) {
41327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41328 }
41329 arg2 = static_cast< size_t >(val2);
41330 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41331 if (!SWIG_IsOK(ecode3)) {
41332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41333 }
41334 arg3 = static_cast< bool >(val3);
41335 {
41336 PyThreadState* __tstate = wxPyBeginAllowThreads();
41337 (arg1)->EnableTop(arg2,arg3);
41338 wxPyEndAllowThreads(__tstate);
41339 if (PyErr_Occurred()) SWIG_fail;
41340 }
41341 resultobj = SWIG_Py_Void();
41342 return resultobj;
41343 fail:
41344 return NULL;
41345 }
41346
41347
41348 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41349 PyObject *resultobj = 0;
41350 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41351 size_t arg2 ;
41352 bool result;
41353 void *argp1 = 0 ;
41354 int res1 = 0 ;
41355 size_t val2 ;
41356 int ecode2 = 0 ;
41357 PyObject * obj0 = 0 ;
41358 PyObject * obj1 = 0 ;
41359 char * kwnames[] = {
41360 (char *) "self",(char *) "pos", NULL
41361 };
41362
41363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41365 if (!SWIG_IsOK(res1)) {
41366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41367 }
41368 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41369 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41370 if (!SWIG_IsOK(ecode2)) {
41371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41372 }
41373 arg2 = static_cast< size_t >(val2);
41374 {
41375 PyThreadState* __tstate = wxPyBeginAllowThreads();
41376 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41377 wxPyEndAllowThreads(__tstate);
41378 if (PyErr_Occurred()) SWIG_fail;
41379 }
41380 {
41381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41382 }
41383 return resultobj;
41384 fail:
41385 return NULL;
41386 }
41387
41388
41389 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41390 PyObject *resultobj = 0;
41391 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41392 size_t arg2 ;
41393 wxString *arg3 = 0 ;
41394 void *argp1 = 0 ;
41395 int res1 = 0 ;
41396 size_t val2 ;
41397 int ecode2 = 0 ;
41398 bool temp3 = false ;
41399 PyObject * obj0 = 0 ;
41400 PyObject * obj1 = 0 ;
41401 PyObject * obj2 = 0 ;
41402 char * kwnames[] = {
41403 (char *) "self",(char *) "pos",(char *) "label", NULL
41404 };
41405
41406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41408 if (!SWIG_IsOK(res1)) {
41409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41410 }
41411 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41412 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41413 if (!SWIG_IsOK(ecode2)) {
41414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41415 }
41416 arg2 = static_cast< size_t >(val2);
41417 {
41418 arg3 = wxString_in_helper(obj2);
41419 if (arg3 == NULL) SWIG_fail;
41420 temp3 = true;
41421 }
41422 {
41423 PyThreadState* __tstate = wxPyBeginAllowThreads();
41424 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41425 wxPyEndAllowThreads(__tstate);
41426 if (PyErr_Occurred()) SWIG_fail;
41427 }
41428 resultobj = SWIG_Py_Void();
41429 {
41430 if (temp3)
41431 delete arg3;
41432 }
41433 return resultobj;
41434 fail:
41435 {
41436 if (temp3)
41437 delete arg3;
41438 }
41439 return NULL;
41440 }
41441
41442
41443 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41444 PyObject *resultobj = 0;
41445 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41446 size_t arg2 ;
41447 wxString result;
41448 void *argp1 = 0 ;
41449 int res1 = 0 ;
41450 size_t val2 ;
41451 int ecode2 = 0 ;
41452 PyObject * obj0 = 0 ;
41453 PyObject * obj1 = 0 ;
41454 char * kwnames[] = {
41455 (char *) "self",(char *) "pos", NULL
41456 };
41457
41458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",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_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41462 }
41463 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41464 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41465 if (!SWIG_IsOK(ecode2)) {
41466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41467 }
41468 arg2 = static_cast< size_t >(val2);
41469 {
41470 PyThreadState* __tstate = wxPyBeginAllowThreads();
41471 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41472 wxPyEndAllowThreads(__tstate);
41473 if (PyErr_Occurred()) SWIG_fail;
41474 }
41475 {
41476 #if wxUSE_UNICODE
41477 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41478 #else
41479 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41480 #endif
41481 }
41482 return resultobj;
41483 fail:
41484 return NULL;
41485 }
41486
41487
41488 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41489 PyObject *resultobj = 0;
41490 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41491 wxString *arg2 = 0 ;
41492 wxString *arg3 = 0 ;
41493 int result;
41494 void *argp1 = 0 ;
41495 int res1 = 0 ;
41496 bool temp2 = false ;
41497 bool temp3 = false ;
41498 PyObject * obj0 = 0 ;
41499 PyObject * obj1 = 0 ;
41500 PyObject * obj2 = 0 ;
41501 char * kwnames[] = {
41502 (char *) "self",(char *) "menu",(char *) "item", NULL
41503 };
41504
41505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41507 if (!SWIG_IsOK(res1)) {
41508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41509 }
41510 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41511 {
41512 arg2 = wxString_in_helper(obj1);
41513 if (arg2 == NULL) SWIG_fail;
41514 temp2 = true;
41515 }
41516 {
41517 arg3 = wxString_in_helper(obj2);
41518 if (arg3 == NULL) SWIG_fail;
41519 temp3 = true;
41520 }
41521 {
41522 PyThreadState* __tstate = wxPyBeginAllowThreads();
41523 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41524 wxPyEndAllowThreads(__tstate);
41525 if (PyErr_Occurred()) SWIG_fail;
41526 }
41527 resultobj = SWIG_From_int(static_cast< int >(result));
41528 {
41529 if (temp2)
41530 delete arg2;
41531 }
41532 {
41533 if (temp3)
41534 delete arg3;
41535 }
41536 return resultobj;
41537 fail:
41538 {
41539 if (temp2)
41540 delete arg2;
41541 }
41542 {
41543 if (temp3)
41544 delete arg3;
41545 }
41546 return NULL;
41547 }
41548
41549
41550 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41551 PyObject *resultobj = 0;
41552 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41553 int arg2 ;
41554 wxMenuItem *result = 0 ;
41555 void *argp1 = 0 ;
41556 int res1 = 0 ;
41557 int val2 ;
41558 int ecode2 = 0 ;
41559 PyObject * obj0 = 0 ;
41560 PyObject * obj1 = 0 ;
41561 char * kwnames[] = {
41562 (char *) "self",(char *) "id", NULL
41563 };
41564
41565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41567 if (!SWIG_IsOK(res1)) {
41568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41569 }
41570 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41571 ecode2 = SWIG_AsVal_int(obj1, &val2);
41572 if (!SWIG_IsOK(ecode2)) {
41573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41574 }
41575 arg2 = static_cast< int >(val2);
41576 {
41577 PyThreadState* __tstate = wxPyBeginAllowThreads();
41578 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41579 wxPyEndAllowThreads(__tstate);
41580 if (PyErr_Occurred()) SWIG_fail;
41581 }
41582 {
41583 resultobj = wxPyMake_wxObject(result, (bool)0);
41584 }
41585 return resultobj;
41586 fail:
41587 return NULL;
41588 }
41589
41590
41591 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41592 PyObject *resultobj = 0;
41593 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41594 wxString *arg2 = 0 ;
41595 int result;
41596 void *argp1 = 0 ;
41597 int res1 = 0 ;
41598 bool temp2 = false ;
41599 PyObject * obj0 = 0 ;
41600 PyObject * obj1 = 0 ;
41601 char * kwnames[] = {
41602 (char *) "self",(char *) "title", NULL
41603 };
41604
41605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41607 if (!SWIG_IsOK(res1)) {
41608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41609 }
41610 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41611 {
41612 arg2 = wxString_in_helper(obj1);
41613 if (arg2 == NULL) SWIG_fail;
41614 temp2 = true;
41615 }
41616 {
41617 PyThreadState* __tstate = wxPyBeginAllowThreads();
41618 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41619 wxPyEndAllowThreads(__tstate);
41620 if (PyErr_Occurred()) SWIG_fail;
41621 }
41622 resultobj = SWIG_From_int(static_cast< int >(result));
41623 {
41624 if (temp2)
41625 delete arg2;
41626 }
41627 return resultobj;
41628 fail:
41629 {
41630 if (temp2)
41631 delete arg2;
41632 }
41633 return NULL;
41634 }
41635
41636
41637 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41638 PyObject *resultobj = 0;
41639 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41640 int arg2 ;
41641 bool arg3 ;
41642 void *argp1 = 0 ;
41643 int res1 = 0 ;
41644 int val2 ;
41645 int ecode2 = 0 ;
41646 bool val3 ;
41647 int ecode3 = 0 ;
41648 PyObject * obj0 = 0 ;
41649 PyObject * obj1 = 0 ;
41650 PyObject * obj2 = 0 ;
41651 char * kwnames[] = {
41652 (char *) "self",(char *) "id",(char *) "enable", NULL
41653 };
41654
41655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41657 if (!SWIG_IsOK(res1)) {
41658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41659 }
41660 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41661 ecode2 = SWIG_AsVal_int(obj1, &val2);
41662 if (!SWIG_IsOK(ecode2)) {
41663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41664 }
41665 arg2 = static_cast< int >(val2);
41666 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41667 if (!SWIG_IsOK(ecode3)) {
41668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41669 }
41670 arg3 = static_cast< bool >(val3);
41671 {
41672 PyThreadState* __tstate = wxPyBeginAllowThreads();
41673 (arg1)->Enable(arg2,arg3);
41674 wxPyEndAllowThreads(__tstate);
41675 if (PyErr_Occurred()) SWIG_fail;
41676 }
41677 resultobj = SWIG_Py_Void();
41678 return resultobj;
41679 fail:
41680 return NULL;
41681 }
41682
41683
41684 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41685 PyObject *resultobj = 0;
41686 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41687 int arg2 ;
41688 bool arg3 ;
41689 void *argp1 = 0 ;
41690 int res1 = 0 ;
41691 int val2 ;
41692 int ecode2 = 0 ;
41693 bool val3 ;
41694 int ecode3 = 0 ;
41695 PyObject * obj0 = 0 ;
41696 PyObject * obj1 = 0 ;
41697 PyObject * obj2 = 0 ;
41698 char * kwnames[] = {
41699 (char *) "self",(char *) "id",(char *) "check", NULL
41700 };
41701
41702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41704 if (!SWIG_IsOK(res1)) {
41705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41706 }
41707 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41708 ecode2 = SWIG_AsVal_int(obj1, &val2);
41709 if (!SWIG_IsOK(ecode2)) {
41710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41711 }
41712 arg2 = static_cast< int >(val2);
41713 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41714 if (!SWIG_IsOK(ecode3)) {
41715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41716 }
41717 arg3 = static_cast< bool >(val3);
41718 {
41719 PyThreadState* __tstate = wxPyBeginAllowThreads();
41720 (arg1)->Check(arg2,arg3);
41721 wxPyEndAllowThreads(__tstate);
41722 if (PyErr_Occurred()) SWIG_fail;
41723 }
41724 resultobj = SWIG_Py_Void();
41725 return resultobj;
41726 fail:
41727 return NULL;
41728 }
41729
41730
41731 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41732 PyObject *resultobj = 0;
41733 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41734 int arg2 ;
41735 bool result;
41736 void *argp1 = 0 ;
41737 int res1 = 0 ;
41738 int val2 ;
41739 int ecode2 = 0 ;
41740 PyObject * obj0 = 0 ;
41741 PyObject * obj1 = 0 ;
41742 char * kwnames[] = {
41743 (char *) "self",(char *) "id", NULL
41744 };
41745
41746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41748 if (!SWIG_IsOK(res1)) {
41749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41750 }
41751 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41752 ecode2 = SWIG_AsVal_int(obj1, &val2);
41753 if (!SWIG_IsOK(ecode2)) {
41754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41755 }
41756 arg2 = static_cast< int >(val2);
41757 {
41758 PyThreadState* __tstate = wxPyBeginAllowThreads();
41759 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41760 wxPyEndAllowThreads(__tstate);
41761 if (PyErr_Occurred()) SWIG_fail;
41762 }
41763 {
41764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41765 }
41766 return resultobj;
41767 fail:
41768 return NULL;
41769 }
41770
41771
41772 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41773 PyObject *resultobj = 0;
41774 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41775 int arg2 ;
41776 bool result;
41777 void *argp1 = 0 ;
41778 int res1 = 0 ;
41779 int val2 ;
41780 int ecode2 = 0 ;
41781 PyObject * obj0 = 0 ;
41782 PyObject * obj1 = 0 ;
41783 char * kwnames[] = {
41784 (char *) "self",(char *) "id", NULL
41785 };
41786
41787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41789 if (!SWIG_IsOK(res1)) {
41790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41791 }
41792 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41793 ecode2 = SWIG_AsVal_int(obj1, &val2);
41794 if (!SWIG_IsOK(ecode2)) {
41795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41796 }
41797 arg2 = static_cast< int >(val2);
41798 {
41799 PyThreadState* __tstate = wxPyBeginAllowThreads();
41800 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41801 wxPyEndAllowThreads(__tstate);
41802 if (PyErr_Occurred()) SWIG_fail;
41803 }
41804 {
41805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41806 }
41807 return resultobj;
41808 fail:
41809 return NULL;
41810 }
41811
41812
41813 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41814 PyObject *resultobj = 0;
41815 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41816 int arg2 ;
41817 wxString *arg3 = 0 ;
41818 void *argp1 = 0 ;
41819 int res1 = 0 ;
41820 int val2 ;
41821 int ecode2 = 0 ;
41822 bool temp3 = false ;
41823 PyObject * obj0 = 0 ;
41824 PyObject * obj1 = 0 ;
41825 PyObject * obj2 = 0 ;
41826 char * kwnames[] = {
41827 (char *) "self",(char *) "id",(char *) "label", NULL
41828 };
41829
41830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41832 if (!SWIG_IsOK(res1)) {
41833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41834 }
41835 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41836 ecode2 = SWIG_AsVal_int(obj1, &val2);
41837 if (!SWIG_IsOK(ecode2)) {
41838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41839 }
41840 arg2 = static_cast< int >(val2);
41841 {
41842 arg3 = wxString_in_helper(obj2);
41843 if (arg3 == NULL) SWIG_fail;
41844 temp3 = true;
41845 }
41846 {
41847 PyThreadState* __tstate = wxPyBeginAllowThreads();
41848 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41849 wxPyEndAllowThreads(__tstate);
41850 if (PyErr_Occurred()) SWIG_fail;
41851 }
41852 resultobj = SWIG_Py_Void();
41853 {
41854 if (temp3)
41855 delete arg3;
41856 }
41857 return resultobj;
41858 fail:
41859 {
41860 if (temp3)
41861 delete arg3;
41862 }
41863 return NULL;
41864 }
41865
41866
41867 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41868 PyObject *resultobj = 0;
41869 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41870 int arg2 ;
41871 wxString result;
41872 void *argp1 = 0 ;
41873 int res1 = 0 ;
41874 int val2 ;
41875 int ecode2 = 0 ;
41876 PyObject * obj0 = 0 ;
41877 PyObject * obj1 = 0 ;
41878 char * kwnames[] = {
41879 (char *) "self",(char *) "id", NULL
41880 };
41881
41882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41884 if (!SWIG_IsOK(res1)) {
41885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41886 }
41887 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41888 ecode2 = SWIG_AsVal_int(obj1, &val2);
41889 if (!SWIG_IsOK(ecode2)) {
41890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41891 }
41892 arg2 = static_cast< int >(val2);
41893 {
41894 PyThreadState* __tstate = wxPyBeginAllowThreads();
41895 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41896 wxPyEndAllowThreads(__tstate);
41897 if (PyErr_Occurred()) SWIG_fail;
41898 }
41899 {
41900 #if wxUSE_UNICODE
41901 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41902 #else
41903 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41904 #endif
41905 }
41906 return resultobj;
41907 fail:
41908 return NULL;
41909 }
41910
41911
41912 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41913 PyObject *resultobj = 0;
41914 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41915 int arg2 ;
41916 wxString *arg3 = 0 ;
41917 void *argp1 = 0 ;
41918 int res1 = 0 ;
41919 int val2 ;
41920 int ecode2 = 0 ;
41921 bool temp3 = false ;
41922 PyObject * obj0 = 0 ;
41923 PyObject * obj1 = 0 ;
41924 PyObject * obj2 = 0 ;
41925 char * kwnames[] = {
41926 (char *) "self",(char *) "id",(char *) "helpString", NULL
41927 };
41928
41929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41931 if (!SWIG_IsOK(res1)) {
41932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41933 }
41934 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41935 ecode2 = SWIG_AsVal_int(obj1, &val2);
41936 if (!SWIG_IsOK(ecode2)) {
41937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41938 }
41939 arg2 = static_cast< int >(val2);
41940 {
41941 arg3 = wxString_in_helper(obj2);
41942 if (arg3 == NULL) SWIG_fail;
41943 temp3 = true;
41944 }
41945 {
41946 PyThreadState* __tstate = wxPyBeginAllowThreads();
41947 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41948 wxPyEndAllowThreads(__tstate);
41949 if (PyErr_Occurred()) SWIG_fail;
41950 }
41951 resultobj = SWIG_Py_Void();
41952 {
41953 if (temp3)
41954 delete arg3;
41955 }
41956 return resultobj;
41957 fail:
41958 {
41959 if (temp3)
41960 delete arg3;
41961 }
41962 return NULL;
41963 }
41964
41965
41966 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41967 PyObject *resultobj = 0;
41968 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41969 int arg2 ;
41970 wxString result;
41971 void *argp1 = 0 ;
41972 int res1 = 0 ;
41973 int val2 ;
41974 int ecode2 = 0 ;
41975 PyObject * obj0 = 0 ;
41976 PyObject * obj1 = 0 ;
41977 char * kwnames[] = {
41978 (char *) "self",(char *) "id", NULL
41979 };
41980
41981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41983 if (!SWIG_IsOK(res1)) {
41984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41985 }
41986 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41987 ecode2 = SWIG_AsVal_int(obj1, &val2);
41988 if (!SWIG_IsOK(ecode2)) {
41989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41990 }
41991 arg2 = static_cast< int >(val2);
41992 {
41993 PyThreadState* __tstate = wxPyBeginAllowThreads();
41994 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41995 wxPyEndAllowThreads(__tstate);
41996 if (PyErr_Occurred()) SWIG_fail;
41997 }
41998 {
41999 #if wxUSE_UNICODE
42000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42001 #else
42002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42003 #endif
42004 }
42005 return resultobj;
42006 fail:
42007 return NULL;
42008 }
42009
42010
42011 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42012 PyObject *resultobj = 0;
42013 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42014 wxFrame *result = 0 ;
42015 void *argp1 = 0 ;
42016 int res1 = 0 ;
42017 PyObject *swig_obj[1] ;
42018
42019 if (!args) SWIG_fail;
42020 swig_obj[0] = args;
42021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42022 if (!SWIG_IsOK(res1)) {
42023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42024 }
42025 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42026 {
42027 PyThreadState* __tstate = wxPyBeginAllowThreads();
42028 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42029 wxPyEndAllowThreads(__tstate);
42030 if (PyErr_Occurred()) SWIG_fail;
42031 }
42032 {
42033 resultobj = wxPyMake_wxObject(result, (bool)0);
42034 }
42035 return resultobj;
42036 fail:
42037 return NULL;
42038 }
42039
42040
42041 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42042 PyObject *resultobj = 0;
42043 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42044 bool result;
42045 void *argp1 = 0 ;
42046 int res1 = 0 ;
42047 PyObject *swig_obj[1] ;
42048
42049 if (!args) SWIG_fail;
42050 swig_obj[0] = args;
42051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42052 if (!SWIG_IsOK(res1)) {
42053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42054 }
42055 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42056 {
42057 PyThreadState* __tstate = wxPyBeginAllowThreads();
42058 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42059 wxPyEndAllowThreads(__tstate);
42060 if (PyErr_Occurred()) SWIG_fail;
42061 }
42062 {
42063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42064 }
42065 return resultobj;
42066 fail:
42067 return NULL;
42068 }
42069
42070
42071 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42072 PyObject *resultobj = 0;
42073 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42074 wxFrame *arg2 = (wxFrame *) 0 ;
42075 void *argp1 = 0 ;
42076 int res1 = 0 ;
42077 void *argp2 = 0 ;
42078 int res2 = 0 ;
42079 PyObject * obj0 = 0 ;
42080 PyObject * obj1 = 0 ;
42081 char * kwnames[] = {
42082 (char *) "self",(char *) "frame", NULL
42083 };
42084
42085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42087 if (!SWIG_IsOK(res1)) {
42088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42089 }
42090 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42091 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42092 if (!SWIG_IsOK(res2)) {
42093 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42094 }
42095 arg2 = reinterpret_cast< wxFrame * >(argp2);
42096 {
42097 PyThreadState* __tstate = wxPyBeginAllowThreads();
42098 (arg1)->Attach(arg2);
42099 wxPyEndAllowThreads(__tstate);
42100 if (PyErr_Occurred()) SWIG_fail;
42101 }
42102 resultobj = SWIG_Py_Void();
42103 return resultobj;
42104 fail:
42105 return NULL;
42106 }
42107
42108
42109 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42110 PyObject *resultobj = 0;
42111 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42112 void *argp1 = 0 ;
42113 int res1 = 0 ;
42114 PyObject *swig_obj[1] ;
42115
42116 if (!args) SWIG_fail;
42117 swig_obj[0] = args;
42118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42119 if (!SWIG_IsOK(res1)) {
42120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42121 }
42122 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42123 {
42124 PyThreadState* __tstate = wxPyBeginAllowThreads();
42125 (arg1)->Detach();
42126 wxPyEndAllowThreads(__tstate);
42127 if (PyErr_Occurred()) SWIG_fail;
42128 }
42129 resultobj = SWIG_Py_Void();
42130 return resultobj;
42131 fail:
42132 return NULL;
42133 }
42134
42135
42136 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42137 PyObject *resultobj = 0;
42138 bool arg1 ;
42139 bool val1 ;
42140 int ecode1 = 0 ;
42141 PyObject * obj0 = 0 ;
42142 char * kwnames[] = {
42143 (char *) "enable", NULL
42144 };
42145
42146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42147 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42148 if (!SWIG_IsOK(ecode1)) {
42149 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42150 }
42151 arg1 = static_cast< bool >(val1);
42152 {
42153 PyThreadState* __tstate = wxPyBeginAllowThreads();
42154 wxMenuBar::SetAutoWindowMenu(arg1);
42155 wxPyEndAllowThreads(__tstate);
42156 if (PyErr_Occurred()) SWIG_fail;
42157 }
42158 resultobj = SWIG_Py_Void();
42159 return resultobj;
42160 fail:
42161 return NULL;
42162 }
42163
42164
42165 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42166 PyObject *resultobj = 0;
42167 bool result;
42168
42169 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42170 {
42171 PyThreadState* __tstate = wxPyBeginAllowThreads();
42172 result = (bool)wxMenuBar::GetAutoWindowMenu();
42173 wxPyEndAllowThreads(__tstate);
42174 if (PyErr_Occurred()) SWIG_fail;
42175 }
42176 {
42177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42178 }
42179 return resultobj;
42180 fail:
42181 return NULL;
42182 }
42183
42184
42185 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42186 PyObject *obj;
42187 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42188 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42189 return SWIG_Py_Void();
42190 }
42191
42192 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42193 return SWIG_Python_InitShadowInstance(args);
42194 }
42195
42196 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42197 PyObject *resultobj = 0;
42198 wxMenu *arg1 = (wxMenu *) NULL ;
42199 int arg2 = (int) wxID_ANY ;
42200 wxString const &arg3_defvalue = wxPyEmptyString ;
42201 wxString *arg3 = (wxString *) &arg3_defvalue ;
42202 wxString const &arg4_defvalue = wxPyEmptyString ;
42203 wxString *arg4 = (wxString *) &arg4_defvalue ;
42204 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42205 wxMenu *arg6 = (wxMenu *) NULL ;
42206 wxMenuItem *result = 0 ;
42207 void *argp1 = 0 ;
42208 int res1 = 0 ;
42209 int val2 ;
42210 int ecode2 = 0 ;
42211 bool temp3 = false ;
42212 bool temp4 = false ;
42213 int val5 ;
42214 int ecode5 = 0 ;
42215 void *argp6 = 0 ;
42216 int res6 = 0 ;
42217 PyObject * obj0 = 0 ;
42218 PyObject * obj1 = 0 ;
42219 PyObject * obj2 = 0 ;
42220 PyObject * obj3 = 0 ;
42221 PyObject * obj4 = 0 ;
42222 PyObject * obj5 = 0 ;
42223 char * kwnames[] = {
42224 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42225 };
42226
42227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42228 if (obj0) {
42229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42230 if (!SWIG_IsOK(res1)) {
42231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42232 }
42233 arg1 = reinterpret_cast< wxMenu * >(argp1);
42234 }
42235 if (obj1) {
42236 ecode2 = SWIG_AsVal_int(obj1, &val2);
42237 if (!SWIG_IsOK(ecode2)) {
42238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42239 }
42240 arg2 = static_cast< int >(val2);
42241 }
42242 if (obj2) {
42243 {
42244 arg3 = wxString_in_helper(obj2);
42245 if (arg3 == NULL) SWIG_fail;
42246 temp3 = true;
42247 }
42248 }
42249 if (obj3) {
42250 {
42251 arg4 = wxString_in_helper(obj3);
42252 if (arg4 == NULL) SWIG_fail;
42253 temp4 = true;
42254 }
42255 }
42256 if (obj4) {
42257 ecode5 = SWIG_AsVal_int(obj4, &val5);
42258 if (!SWIG_IsOK(ecode5)) {
42259 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42260 }
42261 arg5 = static_cast< wxItemKind >(val5);
42262 }
42263 if (obj5) {
42264 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42265 if (!SWIG_IsOK(res6)) {
42266 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42267 }
42268 arg6 = reinterpret_cast< wxMenu * >(argp6);
42269 }
42270 {
42271 PyThreadState* __tstate = wxPyBeginAllowThreads();
42272 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42273 wxPyEndAllowThreads(__tstate);
42274 if (PyErr_Occurred()) SWIG_fail;
42275 }
42276 {
42277 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42278 }
42279 {
42280 if (temp3)
42281 delete arg3;
42282 }
42283 {
42284 if (temp4)
42285 delete arg4;
42286 }
42287 return resultobj;
42288 fail:
42289 {
42290 if (temp3)
42291 delete arg3;
42292 }
42293 {
42294 if (temp4)
42295 delete arg4;
42296 }
42297 return NULL;
42298 }
42299
42300
42301 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42302 PyObject *resultobj = 0;
42303 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42304 void *argp1 = 0 ;
42305 int res1 = 0 ;
42306 PyObject *swig_obj[1] ;
42307
42308 if (!args) SWIG_fail;
42309 swig_obj[0] = args;
42310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42311 if (!SWIG_IsOK(res1)) {
42312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42313 }
42314 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42315 {
42316 PyThreadState* __tstate = wxPyBeginAllowThreads();
42317 delete arg1;
42318
42319 wxPyEndAllowThreads(__tstate);
42320 if (PyErr_Occurred()) SWIG_fail;
42321 }
42322 resultobj = SWIG_Py_Void();
42323 return resultobj;
42324 fail:
42325 return NULL;
42326 }
42327
42328
42329 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42330 PyObject *resultobj = 0;
42331 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42332 wxMenu *result = 0 ;
42333 void *argp1 = 0 ;
42334 int res1 = 0 ;
42335 PyObject *swig_obj[1] ;
42336
42337 if (!args) SWIG_fail;
42338 swig_obj[0] = args;
42339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42340 if (!SWIG_IsOK(res1)) {
42341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42342 }
42343 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42344 {
42345 PyThreadState* __tstate = wxPyBeginAllowThreads();
42346 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42347 wxPyEndAllowThreads(__tstate);
42348 if (PyErr_Occurred()) SWIG_fail;
42349 }
42350 {
42351 resultobj = wxPyMake_wxObject(result, 0);
42352 }
42353 return resultobj;
42354 fail:
42355 return NULL;
42356 }
42357
42358
42359 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42360 PyObject *resultobj = 0;
42361 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42362 wxMenu *arg2 = (wxMenu *) 0 ;
42363 void *argp1 = 0 ;
42364 int res1 = 0 ;
42365 void *argp2 = 0 ;
42366 int res2 = 0 ;
42367 PyObject * obj0 = 0 ;
42368 PyObject * obj1 = 0 ;
42369 char * kwnames[] = {
42370 (char *) "self",(char *) "menu", NULL
42371 };
42372
42373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42375 if (!SWIG_IsOK(res1)) {
42376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42377 }
42378 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42379 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42380 if (!SWIG_IsOK(res2)) {
42381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42382 }
42383 arg2 = reinterpret_cast< wxMenu * >(argp2);
42384 {
42385 PyThreadState* __tstate = wxPyBeginAllowThreads();
42386 (arg1)->SetMenu(arg2);
42387 wxPyEndAllowThreads(__tstate);
42388 if (PyErr_Occurred()) SWIG_fail;
42389 }
42390 resultobj = SWIG_Py_Void();
42391 return resultobj;
42392 fail:
42393 return NULL;
42394 }
42395
42396
42397 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42398 PyObject *resultobj = 0;
42399 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42400 int arg2 ;
42401 void *argp1 = 0 ;
42402 int res1 = 0 ;
42403 int val2 ;
42404 int ecode2 = 0 ;
42405 PyObject * obj0 = 0 ;
42406 PyObject * obj1 = 0 ;
42407 char * kwnames[] = {
42408 (char *) "self",(char *) "id", NULL
42409 };
42410
42411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42413 if (!SWIG_IsOK(res1)) {
42414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42415 }
42416 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42417 ecode2 = SWIG_AsVal_int(obj1, &val2);
42418 if (!SWIG_IsOK(ecode2)) {
42419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42420 }
42421 arg2 = static_cast< int >(val2);
42422 {
42423 PyThreadState* __tstate = wxPyBeginAllowThreads();
42424 (arg1)->SetId(arg2);
42425 wxPyEndAllowThreads(__tstate);
42426 if (PyErr_Occurred()) SWIG_fail;
42427 }
42428 resultobj = SWIG_Py_Void();
42429 return resultobj;
42430 fail:
42431 return NULL;
42432 }
42433
42434
42435 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42436 PyObject *resultobj = 0;
42437 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42438 int result;
42439 void *argp1 = 0 ;
42440 int res1 = 0 ;
42441 PyObject *swig_obj[1] ;
42442
42443 if (!args) SWIG_fail;
42444 swig_obj[0] = args;
42445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42446 if (!SWIG_IsOK(res1)) {
42447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42448 }
42449 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42450 {
42451 PyThreadState* __tstate = wxPyBeginAllowThreads();
42452 result = (int)((wxMenuItem const *)arg1)->GetId();
42453 wxPyEndAllowThreads(__tstate);
42454 if (PyErr_Occurred()) SWIG_fail;
42455 }
42456 resultobj = SWIG_From_int(static_cast< int >(result));
42457 return resultobj;
42458 fail:
42459 return NULL;
42460 }
42461
42462
42463 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42464 PyObject *resultobj = 0;
42465 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42466 bool result;
42467 void *argp1 = 0 ;
42468 int res1 = 0 ;
42469 PyObject *swig_obj[1] ;
42470
42471 if (!args) SWIG_fail;
42472 swig_obj[0] = args;
42473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42474 if (!SWIG_IsOK(res1)) {
42475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42476 }
42477 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42478 {
42479 PyThreadState* __tstate = wxPyBeginAllowThreads();
42480 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42481 wxPyEndAllowThreads(__tstate);
42482 if (PyErr_Occurred()) SWIG_fail;
42483 }
42484 {
42485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42486 }
42487 return resultobj;
42488 fail:
42489 return NULL;
42490 }
42491
42492
42493 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42494 PyObject *resultobj = 0;
42495 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42496 wxString *arg2 = 0 ;
42497 void *argp1 = 0 ;
42498 int res1 = 0 ;
42499 bool temp2 = false ;
42500 PyObject * obj0 = 0 ;
42501 PyObject * obj1 = 0 ;
42502 char * kwnames[] = {
42503 (char *) "self",(char *) "str", NULL
42504 };
42505
42506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42508 if (!SWIG_IsOK(res1)) {
42509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42510 }
42511 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42512 {
42513 arg2 = wxString_in_helper(obj1);
42514 if (arg2 == NULL) SWIG_fail;
42515 temp2 = true;
42516 }
42517 {
42518 PyThreadState* __tstate = wxPyBeginAllowThreads();
42519 (arg1)->SetText((wxString const &)*arg2);
42520 wxPyEndAllowThreads(__tstate);
42521 if (PyErr_Occurred()) SWIG_fail;
42522 }
42523 resultobj = SWIG_Py_Void();
42524 {
42525 if (temp2)
42526 delete arg2;
42527 }
42528 return resultobj;
42529 fail:
42530 {
42531 if (temp2)
42532 delete arg2;
42533 }
42534 return NULL;
42535 }
42536
42537
42538 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42539 PyObject *resultobj = 0;
42540 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42541 wxString result;
42542 void *argp1 = 0 ;
42543 int res1 = 0 ;
42544 PyObject *swig_obj[1] ;
42545
42546 if (!args) SWIG_fail;
42547 swig_obj[0] = args;
42548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42549 if (!SWIG_IsOK(res1)) {
42550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42551 }
42552 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42553 {
42554 PyThreadState* __tstate = wxPyBeginAllowThreads();
42555 result = ((wxMenuItem const *)arg1)->GetLabel();
42556 wxPyEndAllowThreads(__tstate);
42557 if (PyErr_Occurred()) SWIG_fail;
42558 }
42559 {
42560 #if wxUSE_UNICODE
42561 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42562 #else
42563 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42564 #endif
42565 }
42566 return resultobj;
42567 fail:
42568 return NULL;
42569 }
42570
42571
42572 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42573 PyObject *resultobj = 0;
42574 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42575 wxString *result = 0 ;
42576 void *argp1 = 0 ;
42577 int res1 = 0 ;
42578 PyObject *swig_obj[1] ;
42579
42580 if (!args) SWIG_fail;
42581 swig_obj[0] = args;
42582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42583 if (!SWIG_IsOK(res1)) {
42584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42585 }
42586 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42587 {
42588 PyThreadState* __tstate = wxPyBeginAllowThreads();
42589 {
42590 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42591 result = (wxString *) &_result_ref;
42592 }
42593 wxPyEndAllowThreads(__tstate);
42594 if (PyErr_Occurred()) SWIG_fail;
42595 }
42596 {
42597 #if wxUSE_UNICODE
42598 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42599 #else
42600 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42601 #endif
42602 }
42603 return resultobj;
42604 fail:
42605 return NULL;
42606 }
42607
42608
42609 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42610 PyObject *resultobj = 0;
42611 wxString *arg1 = 0 ;
42612 wxString result;
42613 bool temp1 = false ;
42614 PyObject * obj0 = 0 ;
42615 char * kwnames[] = {
42616 (char *) "text", NULL
42617 };
42618
42619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42620 {
42621 arg1 = wxString_in_helper(obj0);
42622 if (arg1 == NULL) SWIG_fail;
42623 temp1 = true;
42624 }
42625 {
42626 PyThreadState* __tstate = wxPyBeginAllowThreads();
42627 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42628 wxPyEndAllowThreads(__tstate);
42629 if (PyErr_Occurred()) SWIG_fail;
42630 }
42631 {
42632 #if wxUSE_UNICODE
42633 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42634 #else
42635 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42636 #endif
42637 }
42638 {
42639 if (temp1)
42640 delete arg1;
42641 }
42642 return resultobj;
42643 fail:
42644 {
42645 if (temp1)
42646 delete arg1;
42647 }
42648 return NULL;
42649 }
42650
42651
42652 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42653 PyObject *resultobj = 0;
42654 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42655 wxItemKind result;
42656 void *argp1 = 0 ;
42657 int res1 = 0 ;
42658 PyObject *swig_obj[1] ;
42659
42660 if (!args) SWIG_fail;
42661 swig_obj[0] = args;
42662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42663 if (!SWIG_IsOK(res1)) {
42664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42665 }
42666 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42667 {
42668 PyThreadState* __tstate = wxPyBeginAllowThreads();
42669 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42670 wxPyEndAllowThreads(__tstate);
42671 if (PyErr_Occurred()) SWIG_fail;
42672 }
42673 resultobj = SWIG_From_int(static_cast< int >(result));
42674 return resultobj;
42675 fail:
42676 return NULL;
42677 }
42678
42679
42680 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42681 PyObject *resultobj = 0;
42682 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42683 wxItemKind arg2 ;
42684 void *argp1 = 0 ;
42685 int res1 = 0 ;
42686 int val2 ;
42687 int ecode2 = 0 ;
42688 PyObject * obj0 = 0 ;
42689 PyObject * obj1 = 0 ;
42690 char * kwnames[] = {
42691 (char *) "self",(char *) "kind", NULL
42692 };
42693
42694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42696 if (!SWIG_IsOK(res1)) {
42697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42698 }
42699 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42700 ecode2 = SWIG_AsVal_int(obj1, &val2);
42701 if (!SWIG_IsOK(ecode2)) {
42702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42703 }
42704 arg2 = static_cast< wxItemKind >(val2);
42705 {
42706 PyThreadState* __tstate = wxPyBeginAllowThreads();
42707 (arg1)->SetKind(arg2);
42708 wxPyEndAllowThreads(__tstate);
42709 if (PyErr_Occurred()) SWIG_fail;
42710 }
42711 resultobj = SWIG_Py_Void();
42712 return resultobj;
42713 fail:
42714 return NULL;
42715 }
42716
42717
42718 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42719 PyObject *resultobj = 0;
42720 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42721 bool arg2 ;
42722 void *argp1 = 0 ;
42723 int res1 = 0 ;
42724 bool val2 ;
42725 int ecode2 = 0 ;
42726 PyObject * obj0 = 0 ;
42727 PyObject * obj1 = 0 ;
42728 char * kwnames[] = {
42729 (char *) "self",(char *) "checkable", NULL
42730 };
42731
42732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42734 if (!SWIG_IsOK(res1)) {
42735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42736 }
42737 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42738 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42739 if (!SWIG_IsOK(ecode2)) {
42740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42741 }
42742 arg2 = static_cast< bool >(val2);
42743 {
42744 PyThreadState* __tstate = wxPyBeginAllowThreads();
42745 (arg1)->SetCheckable(arg2);
42746 wxPyEndAllowThreads(__tstate);
42747 if (PyErr_Occurred()) SWIG_fail;
42748 }
42749 resultobj = SWIG_Py_Void();
42750 return resultobj;
42751 fail:
42752 return NULL;
42753 }
42754
42755
42756 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42757 PyObject *resultobj = 0;
42758 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42759 bool result;
42760 void *argp1 = 0 ;
42761 int res1 = 0 ;
42762 PyObject *swig_obj[1] ;
42763
42764 if (!args) SWIG_fail;
42765 swig_obj[0] = args;
42766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42767 if (!SWIG_IsOK(res1)) {
42768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42769 }
42770 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42771 {
42772 PyThreadState* __tstate = wxPyBeginAllowThreads();
42773 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42774 wxPyEndAllowThreads(__tstate);
42775 if (PyErr_Occurred()) SWIG_fail;
42776 }
42777 {
42778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42779 }
42780 return resultobj;
42781 fail:
42782 return NULL;
42783 }
42784
42785
42786 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42787 PyObject *resultobj = 0;
42788 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42789 bool result;
42790 void *argp1 = 0 ;
42791 int res1 = 0 ;
42792 PyObject *swig_obj[1] ;
42793
42794 if (!args) SWIG_fail;
42795 swig_obj[0] = args;
42796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42797 if (!SWIG_IsOK(res1)) {
42798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42799 }
42800 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42801 {
42802 PyThreadState* __tstate = wxPyBeginAllowThreads();
42803 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42804 wxPyEndAllowThreads(__tstate);
42805 if (PyErr_Occurred()) SWIG_fail;
42806 }
42807 {
42808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42809 }
42810 return resultobj;
42811 fail:
42812 return NULL;
42813 }
42814
42815
42816 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42817 PyObject *resultobj = 0;
42818 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42819 wxMenu *arg2 = (wxMenu *) 0 ;
42820 void *argp1 = 0 ;
42821 int res1 = 0 ;
42822 void *argp2 = 0 ;
42823 int res2 = 0 ;
42824 PyObject * obj0 = 0 ;
42825 PyObject * obj1 = 0 ;
42826 char * kwnames[] = {
42827 (char *) "self",(char *) "menu", NULL
42828 };
42829
42830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42832 if (!SWIG_IsOK(res1)) {
42833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42834 }
42835 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42836 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42837 if (!SWIG_IsOK(res2)) {
42838 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42839 }
42840 arg2 = reinterpret_cast< wxMenu * >(argp2);
42841 {
42842 PyThreadState* __tstate = wxPyBeginAllowThreads();
42843 (arg1)->SetSubMenu(arg2);
42844 wxPyEndAllowThreads(__tstate);
42845 if (PyErr_Occurred()) SWIG_fail;
42846 }
42847 resultobj = SWIG_Py_Void();
42848 return resultobj;
42849 fail:
42850 return NULL;
42851 }
42852
42853
42854 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42855 PyObject *resultobj = 0;
42856 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42857 wxMenu *result = 0 ;
42858 void *argp1 = 0 ;
42859 int res1 = 0 ;
42860 PyObject *swig_obj[1] ;
42861
42862 if (!args) SWIG_fail;
42863 swig_obj[0] = args;
42864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42865 if (!SWIG_IsOK(res1)) {
42866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42867 }
42868 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42869 {
42870 PyThreadState* __tstate = wxPyBeginAllowThreads();
42871 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42872 wxPyEndAllowThreads(__tstate);
42873 if (PyErr_Occurred()) SWIG_fail;
42874 }
42875 {
42876 resultobj = wxPyMake_wxObject(result, 0);
42877 }
42878 return resultobj;
42879 fail:
42880 return NULL;
42881 }
42882
42883
42884 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42885 PyObject *resultobj = 0;
42886 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42887 bool arg2 = (bool) true ;
42888 void *argp1 = 0 ;
42889 int res1 = 0 ;
42890 bool val2 ;
42891 int ecode2 = 0 ;
42892 PyObject * obj0 = 0 ;
42893 PyObject * obj1 = 0 ;
42894 char * kwnames[] = {
42895 (char *) "self",(char *) "enable", NULL
42896 };
42897
42898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42900 if (!SWIG_IsOK(res1)) {
42901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42902 }
42903 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42904 if (obj1) {
42905 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42906 if (!SWIG_IsOK(ecode2)) {
42907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42908 }
42909 arg2 = static_cast< bool >(val2);
42910 }
42911 {
42912 PyThreadState* __tstate = wxPyBeginAllowThreads();
42913 (arg1)->Enable(arg2);
42914 wxPyEndAllowThreads(__tstate);
42915 if (PyErr_Occurred()) SWIG_fail;
42916 }
42917 resultobj = SWIG_Py_Void();
42918 return resultobj;
42919 fail:
42920 return NULL;
42921 }
42922
42923
42924 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42925 PyObject *resultobj = 0;
42926 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42927 bool result;
42928 void *argp1 = 0 ;
42929 int res1 = 0 ;
42930 PyObject *swig_obj[1] ;
42931
42932 if (!args) SWIG_fail;
42933 swig_obj[0] = args;
42934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42935 if (!SWIG_IsOK(res1)) {
42936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42937 }
42938 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42939 {
42940 PyThreadState* __tstate = wxPyBeginAllowThreads();
42941 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42942 wxPyEndAllowThreads(__tstate);
42943 if (PyErr_Occurred()) SWIG_fail;
42944 }
42945 {
42946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42947 }
42948 return resultobj;
42949 fail:
42950 return NULL;
42951 }
42952
42953
42954 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42955 PyObject *resultobj = 0;
42956 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42957 bool arg2 = (bool) true ;
42958 void *argp1 = 0 ;
42959 int res1 = 0 ;
42960 bool val2 ;
42961 int ecode2 = 0 ;
42962 PyObject * obj0 = 0 ;
42963 PyObject * obj1 = 0 ;
42964 char * kwnames[] = {
42965 (char *) "self",(char *) "check", NULL
42966 };
42967
42968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42970 if (!SWIG_IsOK(res1)) {
42971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42972 }
42973 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42974 if (obj1) {
42975 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42976 if (!SWIG_IsOK(ecode2)) {
42977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42978 }
42979 arg2 = static_cast< bool >(val2);
42980 }
42981 {
42982 PyThreadState* __tstate = wxPyBeginAllowThreads();
42983 (arg1)->Check(arg2);
42984 wxPyEndAllowThreads(__tstate);
42985 if (PyErr_Occurred()) SWIG_fail;
42986 }
42987 resultobj = SWIG_Py_Void();
42988 return resultobj;
42989 fail:
42990 return NULL;
42991 }
42992
42993
42994 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42995 PyObject *resultobj = 0;
42996 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42997 bool result;
42998 void *argp1 = 0 ;
42999 int res1 = 0 ;
43000 PyObject *swig_obj[1] ;
43001
43002 if (!args) SWIG_fail;
43003 swig_obj[0] = args;
43004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43005 if (!SWIG_IsOK(res1)) {
43006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43007 }
43008 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43009 {
43010 PyThreadState* __tstate = wxPyBeginAllowThreads();
43011 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43012 wxPyEndAllowThreads(__tstate);
43013 if (PyErr_Occurred()) SWIG_fail;
43014 }
43015 {
43016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43017 }
43018 return resultobj;
43019 fail:
43020 return NULL;
43021 }
43022
43023
43024 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43025 PyObject *resultobj = 0;
43026 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43027 void *argp1 = 0 ;
43028 int res1 = 0 ;
43029 PyObject *swig_obj[1] ;
43030
43031 if (!args) SWIG_fail;
43032 swig_obj[0] = args;
43033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43034 if (!SWIG_IsOK(res1)) {
43035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43036 }
43037 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43038 {
43039 PyThreadState* __tstate = wxPyBeginAllowThreads();
43040 (arg1)->Toggle();
43041 wxPyEndAllowThreads(__tstate);
43042 if (PyErr_Occurred()) SWIG_fail;
43043 }
43044 resultobj = SWIG_Py_Void();
43045 return resultobj;
43046 fail:
43047 return NULL;
43048 }
43049
43050
43051 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43052 PyObject *resultobj = 0;
43053 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43054 wxString *arg2 = 0 ;
43055 void *argp1 = 0 ;
43056 int res1 = 0 ;
43057 bool temp2 = false ;
43058 PyObject * obj0 = 0 ;
43059 PyObject * obj1 = 0 ;
43060 char * kwnames[] = {
43061 (char *) "self",(char *) "str", NULL
43062 };
43063
43064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43066 if (!SWIG_IsOK(res1)) {
43067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43068 }
43069 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43070 {
43071 arg2 = wxString_in_helper(obj1);
43072 if (arg2 == NULL) SWIG_fail;
43073 temp2 = true;
43074 }
43075 {
43076 PyThreadState* __tstate = wxPyBeginAllowThreads();
43077 (arg1)->SetHelp((wxString const &)*arg2);
43078 wxPyEndAllowThreads(__tstate);
43079 if (PyErr_Occurred()) SWIG_fail;
43080 }
43081 resultobj = SWIG_Py_Void();
43082 {
43083 if (temp2)
43084 delete arg2;
43085 }
43086 return resultobj;
43087 fail:
43088 {
43089 if (temp2)
43090 delete arg2;
43091 }
43092 return NULL;
43093 }
43094
43095
43096 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43097 PyObject *resultobj = 0;
43098 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43099 wxString *result = 0 ;
43100 void *argp1 = 0 ;
43101 int res1 = 0 ;
43102 PyObject *swig_obj[1] ;
43103
43104 if (!args) SWIG_fail;
43105 swig_obj[0] = args;
43106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43107 if (!SWIG_IsOK(res1)) {
43108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43109 }
43110 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43111 {
43112 PyThreadState* __tstate = wxPyBeginAllowThreads();
43113 {
43114 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43115 result = (wxString *) &_result_ref;
43116 }
43117 wxPyEndAllowThreads(__tstate);
43118 if (PyErr_Occurred()) SWIG_fail;
43119 }
43120 {
43121 #if wxUSE_UNICODE
43122 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43123 #else
43124 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43125 #endif
43126 }
43127 return resultobj;
43128 fail:
43129 return NULL;
43130 }
43131
43132
43133 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43134 PyObject *resultobj = 0;
43135 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43136 wxAcceleratorEntry *result = 0 ;
43137 void *argp1 = 0 ;
43138 int res1 = 0 ;
43139 PyObject *swig_obj[1] ;
43140
43141 if (!args) SWIG_fail;
43142 swig_obj[0] = args;
43143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43144 if (!SWIG_IsOK(res1)) {
43145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43146 }
43147 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43148 {
43149 PyThreadState* __tstate = wxPyBeginAllowThreads();
43150 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43151 wxPyEndAllowThreads(__tstate);
43152 if (PyErr_Occurred()) SWIG_fail;
43153 }
43154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43155 return resultobj;
43156 fail:
43157 return NULL;
43158 }
43159
43160
43161 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43162 PyObject *resultobj = 0;
43163 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43164 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43165 void *argp1 = 0 ;
43166 int res1 = 0 ;
43167 void *argp2 = 0 ;
43168 int res2 = 0 ;
43169 PyObject * obj0 = 0 ;
43170 PyObject * obj1 = 0 ;
43171 char * kwnames[] = {
43172 (char *) "self",(char *) "accel", NULL
43173 };
43174
43175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43177 if (!SWIG_IsOK(res1)) {
43178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43179 }
43180 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43181 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43182 if (!SWIG_IsOK(res2)) {
43183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43184 }
43185 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43186 {
43187 PyThreadState* __tstate = wxPyBeginAllowThreads();
43188 (arg1)->SetAccel(arg2);
43189 wxPyEndAllowThreads(__tstate);
43190 if (PyErr_Occurred()) SWIG_fail;
43191 }
43192 resultobj = SWIG_Py_Void();
43193 return resultobj;
43194 fail:
43195 return NULL;
43196 }
43197
43198
43199 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43200 PyObject *resultobj = 0;
43201 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43202 wxBitmap *arg2 = 0 ;
43203 void *argp1 = 0 ;
43204 int res1 = 0 ;
43205 void *argp2 = 0 ;
43206 int res2 = 0 ;
43207 PyObject * obj0 = 0 ;
43208 PyObject * obj1 = 0 ;
43209 char * kwnames[] = {
43210 (char *) "self",(char *) "bitmap", NULL
43211 };
43212
43213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43215 if (!SWIG_IsOK(res1)) {
43216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43217 }
43218 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43219 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43220 if (!SWIG_IsOK(res2)) {
43221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43222 }
43223 if (!argp2) {
43224 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43225 }
43226 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43227 {
43228 PyThreadState* __tstate = wxPyBeginAllowThreads();
43229 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43230 wxPyEndAllowThreads(__tstate);
43231 if (PyErr_Occurred()) SWIG_fail;
43232 }
43233 resultobj = SWIG_Py_Void();
43234 return resultobj;
43235 fail:
43236 return NULL;
43237 }
43238
43239
43240 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43241 PyObject *resultobj = 0;
43242 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43243 wxBitmap *result = 0 ;
43244 void *argp1 = 0 ;
43245 int res1 = 0 ;
43246 PyObject *swig_obj[1] ;
43247
43248 if (!args) SWIG_fail;
43249 swig_obj[0] = args;
43250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43251 if (!SWIG_IsOK(res1)) {
43252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43253 }
43254 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43255 {
43256 PyThreadState* __tstate = wxPyBeginAllowThreads();
43257 {
43258 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43259 result = (wxBitmap *) &_result_ref;
43260 }
43261 wxPyEndAllowThreads(__tstate);
43262 if (PyErr_Occurred()) SWIG_fail;
43263 }
43264 {
43265 wxBitmap* resultptr = new wxBitmap(*result);
43266 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43267 }
43268 return resultobj;
43269 fail:
43270 return NULL;
43271 }
43272
43273
43274 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43275 PyObject *resultobj = 0;
43276 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43277 wxFont *arg2 = 0 ;
43278 void *argp1 = 0 ;
43279 int res1 = 0 ;
43280 void *argp2 = 0 ;
43281 int res2 = 0 ;
43282 PyObject * obj0 = 0 ;
43283 PyObject * obj1 = 0 ;
43284 char * kwnames[] = {
43285 (char *) "self",(char *) "font", NULL
43286 };
43287
43288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43290 if (!SWIG_IsOK(res1)) {
43291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43292 }
43293 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43294 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43295 if (!SWIG_IsOK(res2)) {
43296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43297 }
43298 if (!argp2) {
43299 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43300 }
43301 arg2 = reinterpret_cast< wxFont * >(argp2);
43302 {
43303 PyThreadState* __tstate = wxPyBeginAllowThreads();
43304 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43305 wxPyEndAllowThreads(__tstate);
43306 if (PyErr_Occurred()) SWIG_fail;
43307 }
43308 resultobj = SWIG_Py_Void();
43309 return resultobj;
43310 fail:
43311 return NULL;
43312 }
43313
43314
43315 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43316 PyObject *resultobj = 0;
43317 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43318 wxFont result;
43319 void *argp1 = 0 ;
43320 int res1 = 0 ;
43321 PyObject *swig_obj[1] ;
43322
43323 if (!args) SWIG_fail;
43324 swig_obj[0] = args;
43325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43326 if (!SWIG_IsOK(res1)) {
43327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43328 }
43329 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43330 {
43331 PyThreadState* __tstate = wxPyBeginAllowThreads();
43332 result = wxMenuItem_GetFont(arg1);
43333 wxPyEndAllowThreads(__tstate);
43334 if (PyErr_Occurred()) SWIG_fail;
43335 }
43336 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43337 return resultobj;
43338 fail:
43339 return NULL;
43340 }
43341
43342
43343 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43344 PyObject *resultobj = 0;
43345 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43346 wxColour *arg2 = 0 ;
43347 void *argp1 = 0 ;
43348 int res1 = 0 ;
43349 wxColour temp2 ;
43350 PyObject * obj0 = 0 ;
43351 PyObject * obj1 = 0 ;
43352 char * kwnames[] = {
43353 (char *) "self",(char *) "colText", NULL
43354 };
43355
43356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43358 if (!SWIG_IsOK(res1)) {
43359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43360 }
43361 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43362 {
43363 arg2 = &temp2;
43364 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43365 }
43366 {
43367 PyThreadState* __tstate = wxPyBeginAllowThreads();
43368 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43369 wxPyEndAllowThreads(__tstate);
43370 if (PyErr_Occurred()) SWIG_fail;
43371 }
43372 resultobj = SWIG_Py_Void();
43373 return resultobj;
43374 fail:
43375 return NULL;
43376 }
43377
43378
43379 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43380 PyObject *resultobj = 0;
43381 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43382 wxColour result;
43383 void *argp1 = 0 ;
43384 int res1 = 0 ;
43385 PyObject *swig_obj[1] ;
43386
43387 if (!args) SWIG_fail;
43388 swig_obj[0] = args;
43389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43390 if (!SWIG_IsOK(res1)) {
43391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43392 }
43393 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43394 {
43395 PyThreadState* __tstate = wxPyBeginAllowThreads();
43396 result = wxMenuItem_GetTextColour(arg1);
43397 wxPyEndAllowThreads(__tstate);
43398 if (PyErr_Occurred()) SWIG_fail;
43399 }
43400 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43401 return resultobj;
43402 fail:
43403 return NULL;
43404 }
43405
43406
43407 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43408 PyObject *resultobj = 0;
43409 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43410 wxColour *arg2 = 0 ;
43411 void *argp1 = 0 ;
43412 int res1 = 0 ;
43413 wxColour temp2 ;
43414 PyObject * obj0 = 0 ;
43415 PyObject * obj1 = 0 ;
43416 char * kwnames[] = {
43417 (char *) "self",(char *) "colBack", NULL
43418 };
43419
43420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43422 if (!SWIG_IsOK(res1)) {
43423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43424 }
43425 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43426 {
43427 arg2 = &temp2;
43428 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43429 }
43430 {
43431 PyThreadState* __tstate = wxPyBeginAllowThreads();
43432 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43433 wxPyEndAllowThreads(__tstate);
43434 if (PyErr_Occurred()) SWIG_fail;
43435 }
43436 resultobj = SWIG_Py_Void();
43437 return resultobj;
43438 fail:
43439 return NULL;
43440 }
43441
43442
43443 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43444 PyObject *resultobj = 0;
43445 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43446 wxColour result;
43447 void *argp1 = 0 ;
43448 int res1 = 0 ;
43449 PyObject *swig_obj[1] ;
43450
43451 if (!args) SWIG_fail;
43452 swig_obj[0] = args;
43453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43454 if (!SWIG_IsOK(res1)) {
43455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43456 }
43457 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43458 {
43459 PyThreadState* __tstate = wxPyBeginAllowThreads();
43460 result = wxMenuItem_GetBackgroundColour(arg1);
43461 wxPyEndAllowThreads(__tstate);
43462 if (PyErr_Occurred()) SWIG_fail;
43463 }
43464 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43465 return resultobj;
43466 fail:
43467 return NULL;
43468 }
43469
43470
43471 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43472 PyObject *resultobj = 0;
43473 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43474 wxBitmap *arg2 = 0 ;
43475 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43476 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43477 void *argp1 = 0 ;
43478 int res1 = 0 ;
43479 void *argp2 = 0 ;
43480 int res2 = 0 ;
43481 void *argp3 = 0 ;
43482 int res3 = 0 ;
43483 PyObject * obj0 = 0 ;
43484 PyObject * obj1 = 0 ;
43485 PyObject * obj2 = 0 ;
43486 char * kwnames[] = {
43487 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43488 };
43489
43490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43492 if (!SWIG_IsOK(res1)) {
43493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43494 }
43495 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43496 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43497 if (!SWIG_IsOK(res2)) {
43498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43499 }
43500 if (!argp2) {
43501 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43502 }
43503 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43504 if (obj2) {
43505 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43506 if (!SWIG_IsOK(res3)) {
43507 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43508 }
43509 if (!argp3) {
43510 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43511 }
43512 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43513 }
43514 {
43515 PyThreadState* __tstate = wxPyBeginAllowThreads();
43516 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43517 wxPyEndAllowThreads(__tstate);
43518 if (PyErr_Occurred()) SWIG_fail;
43519 }
43520 resultobj = SWIG_Py_Void();
43521 return resultobj;
43522 fail:
43523 return NULL;
43524 }
43525
43526
43527 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43528 PyObject *resultobj = 0;
43529 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43530 wxBitmap *arg2 = 0 ;
43531 void *argp1 = 0 ;
43532 int res1 = 0 ;
43533 void *argp2 = 0 ;
43534 int res2 = 0 ;
43535 PyObject * obj0 = 0 ;
43536 PyObject * obj1 = 0 ;
43537 char * kwnames[] = {
43538 (char *) "self",(char *) "bmpDisabled", NULL
43539 };
43540
43541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43543 if (!SWIG_IsOK(res1)) {
43544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43545 }
43546 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43547 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43548 if (!SWIG_IsOK(res2)) {
43549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43550 }
43551 if (!argp2) {
43552 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43553 }
43554 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43555 {
43556 PyThreadState* __tstate = wxPyBeginAllowThreads();
43557 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43558 wxPyEndAllowThreads(__tstate);
43559 if (PyErr_Occurred()) SWIG_fail;
43560 }
43561 resultobj = SWIG_Py_Void();
43562 return resultobj;
43563 fail:
43564 return NULL;
43565 }
43566
43567
43568 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43569 PyObject *resultobj = 0;
43570 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43571 wxBitmap *result = 0 ;
43572 void *argp1 = 0 ;
43573 int res1 = 0 ;
43574 PyObject *swig_obj[1] ;
43575
43576 if (!args) SWIG_fail;
43577 swig_obj[0] = args;
43578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43579 if (!SWIG_IsOK(res1)) {
43580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43581 }
43582 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43583 {
43584 PyThreadState* __tstate = wxPyBeginAllowThreads();
43585 {
43586 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43587 result = (wxBitmap *) &_result_ref;
43588 }
43589 wxPyEndAllowThreads(__tstate);
43590 if (PyErr_Occurred()) SWIG_fail;
43591 }
43592 {
43593 wxBitmap* resultptr = new wxBitmap(*result);
43594 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43595 }
43596 return resultobj;
43597 fail:
43598 return NULL;
43599 }
43600
43601
43602 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43603 PyObject *resultobj = 0;
43604 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43605 int arg2 ;
43606 void *argp1 = 0 ;
43607 int res1 = 0 ;
43608 int val2 ;
43609 int ecode2 = 0 ;
43610 PyObject * obj0 = 0 ;
43611 PyObject * obj1 = 0 ;
43612 char * kwnames[] = {
43613 (char *) "self",(char *) "nWidth", NULL
43614 };
43615
43616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43618 if (!SWIG_IsOK(res1)) {
43619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43620 }
43621 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43622 ecode2 = SWIG_AsVal_int(obj1, &val2);
43623 if (!SWIG_IsOK(ecode2)) {
43624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43625 }
43626 arg2 = static_cast< int >(val2);
43627 {
43628 PyThreadState* __tstate = wxPyBeginAllowThreads();
43629 wxMenuItem_SetMarginWidth(arg1,arg2);
43630 wxPyEndAllowThreads(__tstate);
43631 if (PyErr_Occurred()) SWIG_fail;
43632 }
43633 resultobj = SWIG_Py_Void();
43634 return resultobj;
43635 fail:
43636 return NULL;
43637 }
43638
43639
43640 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43641 PyObject *resultobj = 0;
43642 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43643 int result;
43644 void *argp1 = 0 ;
43645 int res1 = 0 ;
43646 PyObject *swig_obj[1] ;
43647
43648 if (!args) SWIG_fail;
43649 swig_obj[0] = args;
43650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43651 if (!SWIG_IsOK(res1)) {
43652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43653 }
43654 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43655 {
43656 PyThreadState* __tstate = wxPyBeginAllowThreads();
43657 result = (int)wxMenuItem_GetMarginWidth(arg1);
43658 wxPyEndAllowThreads(__tstate);
43659 if (PyErr_Occurred()) SWIG_fail;
43660 }
43661 resultobj = SWIG_From_int(static_cast< int >(result));
43662 return resultobj;
43663 fail:
43664 return NULL;
43665 }
43666
43667
43668 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43669 PyObject *resultobj = 0;
43670 int result;
43671
43672 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43673 {
43674 PyThreadState* __tstate = wxPyBeginAllowThreads();
43675 result = (int)wxMenuItem_GetDefaultMarginWidth();
43676 wxPyEndAllowThreads(__tstate);
43677 if (PyErr_Occurred()) SWIG_fail;
43678 }
43679 resultobj = SWIG_From_int(static_cast< int >(result));
43680 return resultobj;
43681 fail:
43682 return NULL;
43683 }
43684
43685
43686 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43687 PyObject *resultobj = 0;
43688 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43689 bool result;
43690 void *argp1 = 0 ;
43691 int res1 = 0 ;
43692 PyObject *swig_obj[1] ;
43693
43694 if (!args) SWIG_fail;
43695 swig_obj[0] = args;
43696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43697 if (!SWIG_IsOK(res1)) {
43698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43699 }
43700 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43701 {
43702 PyThreadState* __tstate = wxPyBeginAllowThreads();
43703 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43704 wxPyEndAllowThreads(__tstate);
43705 if (PyErr_Occurred()) SWIG_fail;
43706 }
43707 {
43708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43709 }
43710 return resultobj;
43711 fail:
43712 return NULL;
43713 }
43714
43715
43716 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43717 PyObject *resultobj = 0;
43718 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43719 bool arg2 = (bool) true ;
43720 void *argp1 = 0 ;
43721 int res1 = 0 ;
43722 bool val2 ;
43723 int ecode2 = 0 ;
43724 PyObject * obj0 = 0 ;
43725 PyObject * obj1 = 0 ;
43726 char * kwnames[] = {
43727 (char *) "self",(char *) "ownerDrawn", NULL
43728 };
43729
43730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43732 if (!SWIG_IsOK(res1)) {
43733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43734 }
43735 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43736 if (obj1) {
43737 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43738 if (!SWIG_IsOK(ecode2)) {
43739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43740 }
43741 arg2 = static_cast< bool >(val2);
43742 }
43743 {
43744 PyThreadState* __tstate = wxPyBeginAllowThreads();
43745 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43746 wxPyEndAllowThreads(__tstate);
43747 if (PyErr_Occurred()) SWIG_fail;
43748 }
43749 resultobj = SWIG_Py_Void();
43750 return resultobj;
43751 fail:
43752 return NULL;
43753 }
43754
43755
43756 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43757 PyObject *resultobj = 0;
43758 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43759 void *argp1 = 0 ;
43760 int res1 = 0 ;
43761 PyObject *swig_obj[1] ;
43762
43763 if (!args) SWIG_fail;
43764 swig_obj[0] = args;
43765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43766 if (!SWIG_IsOK(res1)) {
43767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43768 }
43769 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43770 {
43771 PyThreadState* __tstate = wxPyBeginAllowThreads();
43772 wxMenuItem_ResetOwnerDrawn(arg1);
43773 wxPyEndAllowThreads(__tstate);
43774 if (PyErr_Occurred()) SWIG_fail;
43775 }
43776 resultobj = SWIG_Py_Void();
43777 return resultobj;
43778 fail:
43779 return NULL;
43780 }
43781
43782
43783 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43784 PyObject *obj;
43785 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43786 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43787 return SWIG_Py_Void();
43788 }
43789
43790 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43791 return SWIG_Python_InitShadowInstance(args);
43792 }
43793
43794 SWIGINTERN int ControlNameStr_set(PyObject *) {
43795 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43796 return 1;
43797 }
43798
43799
43800 SWIGINTERN PyObject *ControlNameStr_get(void) {
43801 PyObject *pyobj = 0;
43802
43803 {
43804 #if wxUSE_UNICODE
43805 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43806 #else
43807 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43808 #endif
43809 }
43810 return pyobj;
43811 }
43812
43813
43814 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43815 PyObject *resultobj = 0;
43816 wxWindow *arg1 = (wxWindow *) 0 ;
43817 int arg2 = (int) -1 ;
43818 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43819 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43820 wxSize const &arg4_defvalue = wxDefaultSize ;
43821 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43822 long arg5 = (long) 0 ;
43823 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43824 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43825 wxString const &arg7_defvalue = wxPyControlNameStr ;
43826 wxString *arg7 = (wxString *) &arg7_defvalue ;
43827 wxControl *result = 0 ;
43828 void *argp1 = 0 ;
43829 int res1 = 0 ;
43830 int val2 ;
43831 int ecode2 = 0 ;
43832 wxPoint temp3 ;
43833 wxSize temp4 ;
43834 long val5 ;
43835 int ecode5 = 0 ;
43836 void *argp6 = 0 ;
43837 int res6 = 0 ;
43838 bool temp7 = false ;
43839 PyObject * obj0 = 0 ;
43840 PyObject * obj1 = 0 ;
43841 PyObject * obj2 = 0 ;
43842 PyObject * obj3 = 0 ;
43843 PyObject * obj4 = 0 ;
43844 PyObject * obj5 = 0 ;
43845 PyObject * obj6 = 0 ;
43846 char * kwnames[] = {
43847 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43848 };
43849
43850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43852 if (!SWIG_IsOK(res1)) {
43853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43854 }
43855 arg1 = reinterpret_cast< wxWindow * >(argp1);
43856 if (obj1) {
43857 ecode2 = SWIG_AsVal_int(obj1, &val2);
43858 if (!SWIG_IsOK(ecode2)) {
43859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43860 }
43861 arg2 = static_cast< int >(val2);
43862 }
43863 if (obj2) {
43864 {
43865 arg3 = &temp3;
43866 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43867 }
43868 }
43869 if (obj3) {
43870 {
43871 arg4 = &temp4;
43872 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43873 }
43874 }
43875 if (obj4) {
43876 ecode5 = SWIG_AsVal_long(obj4, &val5);
43877 if (!SWIG_IsOK(ecode5)) {
43878 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43879 }
43880 arg5 = static_cast< long >(val5);
43881 }
43882 if (obj5) {
43883 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43884 if (!SWIG_IsOK(res6)) {
43885 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43886 }
43887 if (!argp6) {
43888 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43889 }
43890 arg6 = reinterpret_cast< wxValidator * >(argp6);
43891 }
43892 if (obj6) {
43893 {
43894 arg7 = wxString_in_helper(obj6);
43895 if (arg7 == NULL) SWIG_fail;
43896 temp7 = true;
43897 }
43898 }
43899 {
43900 if (!wxPyCheckForApp()) SWIG_fail;
43901 PyThreadState* __tstate = wxPyBeginAllowThreads();
43902 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43903 wxPyEndAllowThreads(__tstate);
43904 if (PyErr_Occurred()) SWIG_fail;
43905 }
43906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43907 {
43908 if (temp7)
43909 delete arg7;
43910 }
43911 return resultobj;
43912 fail:
43913 {
43914 if (temp7)
43915 delete arg7;
43916 }
43917 return NULL;
43918 }
43919
43920
43921 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43922 PyObject *resultobj = 0;
43923 wxControl *result = 0 ;
43924
43925 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43926 {
43927 if (!wxPyCheckForApp()) SWIG_fail;
43928 PyThreadState* __tstate = wxPyBeginAllowThreads();
43929 result = (wxControl *)new wxControl();
43930 wxPyEndAllowThreads(__tstate);
43931 if (PyErr_Occurred()) SWIG_fail;
43932 }
43933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43934 return resultobj;
43935 fail:
43936 return NULL;
43937 }
43938
43939
43940 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43941 PyObject *resultobj = 0;
43942 wxControl *arg1 = (wxControl *) 0 ;
43943 wxWindow *arg2 = (wxWindow *) 0 ;
43944 int arg3 = (int) -1 ;
43945 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43946 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43947 wxSize const &arg5_defvalue = wxDefaultSize ;
43948 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43949 long arg6 = (long) 0 ;
43950 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43951 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43952 wxString const &arg8_defvalue = wxPyControlNameStr ;
43953 wxString *arg8 = (wxString *) &arg8_defvalue ;
43954 bool result;
43955 void *argp1 = 0 ;
43956 int res1 = 0 ;
43957 void *argp2 = 0 ;
43958 int res2 = 0 ;
43959 int val3 ;
43960 int ecode3 = 0 ;
43961 wxPoint temp4 ;
43962 wxSize temp5 ;
43963 long val6 ;
43964 int ecode6 = 0 ;
43965 void *argp7 = 0 ;
43966 int res7 = 0 ;
43967 bool temp8 = false ;
43968 PyObject * obj0 = 0 ;
43969 PyObject * obj1 = 0 ;
43970 PyObject * obj2 = 0 ;
43971 PyObject * obj3 = 0 ;
43972 PyObject * obj4 = 0 ;
43973 PyObject * obj5 = 0 ;
43974 PyObject * obj6 = 0 ;
43975 PyObject * obj7 = 0 ;
43976 char * kwnames[] = {
43977 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43978 };
43979
43980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43982 if (!SWIG_IsOK(res1)) {
43983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43984 }
43985 arg1 = reinterpret_cast< wxControl * >(argp1);
43986 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43987 if (!SWIG_IsOK(res2)) {
43988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43989 }
43990 arg2 = reinterpret_cast< wxWindow * >(argp2);
43991 if (obj2) {
43992 ecode3 = SWIG_AsVal_int(obj2, &val3);
43993 if (!SWIG_IsOK(ecode3)) {
43994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43995 }
43996 arg3 = static_cast< int >(val3);
43997 }
43998 if (obj3) {
43999 {
44000 arg4 = &temp4;
44001 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44002 }
44003 }
44004 if (obj4) {
44005 {
44006 arg5 = &temp5;
44007 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44008 }
44009 }
44010 if (obj5) {
44011 ecode6 = SWIG_AsVal_long(obj5, &val6);
44012 if (!SWIG_IsOK(ecode6)) {
44013 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44014 }
44015 arg6 = static_cast< long >(val6);
44016 }
44017 if (obj6) {
44018 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44019 if (!SWIG_IsOK(res7)) {
44020 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44021 }
44022 if (!argp7) {
44023 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44024 }
44025 arg7 = reinterpret_cast< wxValidator * >(argp7);
44026 }
44027 if (obj7) {
44028 {
44029 arg8 = wxString_in_helper(obj7);
44030 if (arg8 == NULL) SWIG_fail;
44031 temp8 = true;
44032 }
44033 }
44034 {
44035 PyThreadState* __tstate = wxPyBeginAllowThreads();
44036 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44037 wxPyEndAllowThreads(__tstate);
44038 if (PyErr_Occurred()) SWIG_fail;
44039 }
44040 {
44041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44042 }
44043 {
44044 if (temp8)
44045 delete arg8;
44046 }
44047 return resultobj;
44048 fail:
44049 {
44050 if (temp8)
44051 delete arg8;
44052 }
44053 return NULL;
44054 }
44055
44056
44057 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44058 PyObject *resultobj = 0;
44059 wxControl *arg1 = (wxControl *) 0 ;
44060 wxCommandEvent *arg2 = 0 ;
44061 void *argp1 = 0 ;
44062 int res1 = 0 ;
44063 void *argp2 = 0 ;
44064 int res2 = 0 ;
44065 PyObject * obj0 = 0 ;
44066 PyObject * obj1 = 0 ;
44067 char * kwnames[] = {
44068 (char *) "self",(char *) "event", NULL
44069 };
44070
44071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44073 if (!SWIG_IsOK(res1)) {
44074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44075 }
44076 arg1 = reinterpret_cast< wxControl * >(argp1);
44077 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44078 if (!SWIG_IsOK(res2)) {
44079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44080 }
44081 if (!argp2) {
44082 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44083 }
44084 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44085 {
44086 PyThreadState* __tstate = wxPyBeginAllowThreads();
44087 (arg1)->Command(*arg2);
44088 wxPyEndAllowThreads(__tstate);
44089 if (PyErr_Occurred()) SWIG_fail;
44090 }
44091 resultobj = SWIG_Py_Void();
44092 return resultobj;
44093 fail:
44094 return NULL;
44095 }
44096
44097
44098 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44099 PyObject *resultobj = 0;
44100 wxControl *arg1 = (wxControl *) 0 ;
44101 wxString result;
44102 void *argp1 = 0 ;
44103 int res1 = 0 ;
44104 PyObject *swig_obj[1] ;
44105
44106 if (!args) SWIG_fail;
44107 swig_obj[0] = args;
44108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44109 if (!SWIG_IsOK(res1)) {
44110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44111 }
44112 arg1 = reinterpret_cast< wxControl * >(argp1);
44113 {
44114 PyThreadState* __tstate = wxPyBeginAllowThreads();
44115 result = (arg1)->GetLabel();
44116 wxPyEndAllowThreads(__tstate);
44117 if (PyErr_Occurred()) SWIG_fail;
44118 }
44119 {
44120 #if wxUSE_UNICODE
44121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44122 #else
44123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44124 #endif
44125 }
44126 return resultobj;
44127 fail:
44128 return NULL;
44129 }
44130
44131
44132 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44133 PyObject *resultobj = 0;
44134 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44135 SwigValueWrapper<wxVisualAttributes > result;
44136 int val1 ;
44137 int ecode1 = 0 ;
44138 PyObject * obj0 = 0 ;
44139 char * kwnames[] = {
44140 (char *) "variant", NULL
44141 };
44142
44143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44144 if (obj0) {
44145 ecode1 = SWIG_AsVal_int(obj0, &val1);
44146 if (!SWIG_IsOK(ecode1)) {
44147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44148 }
44149 arg1 = static_cast< wxWindowVariant >(val1);
44150 }
44151 {
44152 if (!wxPyCheckForApp()) SWIG_fail;
44153 PyThreadState* __tstate = wxPyBeginAllowThreads();
44154 result = wxControl::GetClassDefaultAttributes(arg1);
44155 wxPyEndAllowThreads(__tstate);
44156 if (PyErr_Occurred()) SWIG_fail;
44157 }
44158 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44159 return resultobj;
44160 fail:
44161 return NULL;
44162 }
44163
44164
44165 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44166 PyObject *obj;
44167 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44168 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44169 return SWIG_Py_Void();
44170 }
44171
44172 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44173 return SWIG_Python_InitShadowInstance(args);
44174 }
44175
44176 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44177 PyObject *resultobj = 0;
44178 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44179 wxString *arg2 = 0 ;
44180 PyObject *arg3 = (PyObject *) NULL ;
44181 int result;
44182 void *argp1 = 0 ;
44183 int res1 = 0 ;
44184 bool temp2 = false ;
44185 PyObject * obj0 = 0 ;
44186 PyObject * obj1 = 0 ;
44187 PyObject * obj2 = 0 ;
44188 char * kwnames[] = {
44189 (char *) "self",(char *) "item",(char *) "clientData", NULL
44190 };
44191
44192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44194 if (!SWIG_IsOK(res1)) {
44195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44196 }
44197 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44198 {
44199 arg2 = wxString_in_helper(obj1);
44200 if (arg2 == NULL) SWIG_fail;
44201 temp2 = true;
44202 }
44203 if (obj2) {
44204 arg3 = obj2;
44205 }
44206 {
44207 PyThreadState* __tstate = wxPyBeginAllowThreads();
44208 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44209 wxPyEndAllowThreads(__tstate);
44210 if (PyErr_Occurred()) SWIG_fail;
44211 }
44212 resultobj = SWIG_From_int(static_cast< int >(result));
44213 {
44214 if (temp2)
44215 delete arg2;
44216 }
44217 return resultobj;
44218 fail:
44219 {
44220 if (temp2)
44221 delete arg2;
44222 }
44223 return NULL;
44224 }
44225
44226
44227 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44228 PyObject *resultobj = 0;
44229 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44230 wxArrayString *arg2 = 0 ;
44231 void *argp1 = 0 ;
44232 int res1 = 0 ;
44233 bool temp2 = false ;
44234 PyObject * obj0 = 0 ;
44235 PyObject * obj1 = 0 ;
44236 char * kwnames[] = {
44237 (char *) "self",(char *) "strings", NULL
44238 };
44239
44240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44242 if (!SWIG_IsOK(res1)) {
44243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44244 }
44245 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44246 {
44247 if (! PySequence_Check(obj1)) {
44248 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44249 SWIG_fail;
44250 }
44251 arg2 = new wxArrayString;
44252 temp2 = true;
44253 int i, len=PySequence_Length(obj1);
44254 for (i=0; i<len; i++) {
44255 PyObject* item = PySequence_GetItem(obj1, i);
44256 wxString* s = wxString_in_helper(item);
44257 if (PyErr_Occurred()) SWIG_fail;
44258 arg2->Add(*s);
44259 delete s;
44260 Py_DECREF(item);
44261 }
44262 }
44263 {
44264 PyThreadState* __tstate = wxPyBeginAllowThreads();
44265 (arg1)->Append((wxArrayString const &)*arg2);
44266 wxPyEndAllowThreads(__tstate);
44267 if (PyErr_Occurred()) SWIG_fail;
44268 }
44269 resultobj = SWIG_Py_Void();
44270 {
44271 if (temp2) delete arg2;
44272 }
44273 return resultobj;
44274 fail:
44275 {
44276 if (temp2) delete arg2;
44277 }
44278 return NULL;
44279 }
44280
44281
44282 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44283 PyObject *resultobj = 0;
44284 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44285 wxString *arg2 = 0 ;
44286 unsigned int arg3 ;
44287 PyObject *arg4 = (PyObject *) NULL ;
44288 int result;
44289 void *argp1 = 0 ;
44290 int res1 = 0 ;
44291 bool temp2 = false ;
44292 unsigned int val3 ;
44293 int ecode3 = 0 ;
44294 PyObject * obj0 = 0 ;
44295 PyObject * obj1 = 0 ;
44296 PyObject * obj2 = 0 ;
44297 PyObject * obj3 = 0 ;
44298 char * kwnames[] = {
44299 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44300 };
44301
44302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44304 if (!SWIG_IsOK(res1)) {
44305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44306 }
44307 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44308 {
44309 arg2 = wxString_in_helper(obj1);
44310 if (arg2 == NULL) SWIG_fail;
44311 temp2 = true;
44312 }
44313 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44314 if (!SWIG_IsOK(ecode3)) {
44315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44316 }
44317 arg3 = static_cast< unsigned int >(val3);
44318 if (obj3) {
44319 arg4 = obj3;
44320 }
44321 {
44322 PyThreadState* __tstate = wxPyBeginAllowThreads();
44323 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44324 wxPyEndAllowThreads(__tstate);
44325 if (PyErr_Occurred()) SWIG_fail;
44326 }
44327 resultobj = SWIG_From_int(static_cast< int >(result));
44328 {
44329 if (temp2)
44330 delete arg2;
44331 }
44332 return resultobj;
44333 fail:
44334 {
44335 if (temp2)
44336 delete arg2;
44337 }
44338 return NULL;
44339 }
44340
44341
44342 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44343 PyObject *resultobj = 0;
44344 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44345 void *argp1 = 0 ;
44346 int res1 = 0 ;
44347 PyObject *swig_obj[1] ;
44348
44349 if (!args) SWIG_fail;
44350 swig_obj[0] = args;
44351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44352 if (!SWIG_IsOK(res1)) {
44353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44354 }
44355 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44356 {
44357 PyThreadState* __tstate = wxPyBeginAllowThreads();
44358 (arg1)->Clear();
44359 wxPyEndAllowThreads(__tstate);
44360 if (PyErr_Occurred()) SWIG_fail;
44361 }
44362 resultobj = SWIG_Py_Void();
44363 return resultobj;
44364 fail:
44365 return NULL;
44366 }
44367
44368
44369 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44370 PyObject *resultobj = 0;
44371 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44372 unsigned int arg2 ;
44373 void *argp1 = 0 ;
44374 int res1 = 0 ;
44375 unsigned int val2 ;
44376 int ecode2 = 0 ;
44377 PyObject * obj0 = 0 ;
44378 PyObject * obj1 = 0 ;
44379 char * kwnames[] = {
44380 (char *) "self",(char *) "n", NULL
44381 };
44382
44383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44385 if (!SWIG_IsOK(res1)) {
44386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44387 }
44388 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44389 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44390 if (!SWIG_IsOK(ecode2)) {
44391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44392 }
44393 arg2 = static_cast< unsigned int >(val2);
44394 {
44395 PyThreadState* __tstate = wxPyBeginAllowThreads();
44396 (arg1)->Delete(arg2);
44397 wxPyEndAllowThreads(__tstate);
44398 if (PyErr_Occurred()) SWIG_fail;
44399 }
44400 resultobj = SWIG_Py_Void();
44401 return resultobj;
44402 fail:
44403 return NULL;
44404 }
44405
44406
44407 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44408 PyObject *resultobj = 0;
44409 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44410 unsigned int arg2 ;
44411 PyObject *result = 0 ;
44412 void *argp1 = 0 ;
44413 int res1 = 0 ;
44414 unsigned int val2 ;
44415 int ecode2 = 0 ;
44416 PyObject * obj0 = 0 ;
44417 PyObject * obj1 = 0 ;
44418 char * kwnames[] = {
44419 (char *) "self",(char *) "n", NULL
44420 };
44421
44422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44424 if (!SWIG_IsOK(res1)) {
44425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44426 }
44427 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44428 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44429 if (!SWIG_IsOK(ecode2)) {
44430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44431 }
44432 arg2 = static_cast< unsigned int >(val2);
44433 {
44434 PyThreadState* __tstate = wxPyBeginAllowThreads();
44435 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44436 wxPyEndAllowThreads(__tstate);
44437 if (PyErr_Occurred()) SWIG_fail;
44438 }
44439 resultobj = result;
44440 return resultobj;
44441 fail:
44442 return NULL;
44443 }
44444
44445
44446 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44447 PyObject *resultobj = 0;
44448 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44449 unsigned int arg2 ;
44450 PyObject *arg3 = (PyObject *) 0 ;
44451 void *argp1 = 0 ;
44452 int res1 = 0 ;
44453 unsigned int val2 ;
44454 int ecode2 = 0 ;
44455 PyObject * obj0 = 0 ;
44456 PyObject * obj1 = 0 ;
44457 PyObject * obj2 = 0 ;
44458 char * kwnames[] = {
44459 (char *) "self",(char *) "n",(char *) "clientData", NULL
44460 };
44461
44462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44464 if (!SWIG_IsOK(res1)) {
44465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44466 }
44467 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44468 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44469 if (!SWIG_IsOK(ecode2)) {
44470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44471 }
44472 arg2 = static_cast< unsigned int >(val2);
44473 arg3 = obj2;
44474 {
44475 PyThreadState* __tstate = wxPyBeginAllowThreads();
44476 wxItemContainer_SetClientData(arg1,arg2,arg3);
44477 wxPyEndAllowThreads(__tstate);
44478 if (PyErr_Occurred()) SWIG_fail;
44479 }
44480 resultobj = SWIG_Py_Void();
44481 return resultobj;
44482 fail:
44483 return NULL;
44484 }
44485
44486
44487 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44488 PyObject *resultobj = 0;
44489 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44490 unsigned int result;
44491 void *argp1 = 0 ;
44492 int res1 = 0 ;
44493 PyObject *swig_obj[1] ;
44494
44495 if (!args) SWIG_fail;
44496 swig_obj[0] = args;
44497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44498 if (!SWIG_IsOK(res1)) {
44499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44500 }
44501 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44502 {
44503 PyThreadState* __tstate = wxPyBeginAllowThreads();
44504 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44505 wxPyEndAllowThreads(__tstate);
44506 if (PyErr_Occurred()) SWIG_fail;
44507 }
44508 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44509 return resultobj;
44510 fail:
44511 return NULL;
44512 }
44513
44514
44515 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44516 PyObject *resultobj = 0;
44517 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44518 bool result;
44519 void *argp1 = 0 ;
44520 int res1 = 0 ;
44521 PyObject *swig_obj[1] ;
44522
44523 if (!args) SWIG_fail;
44524 swig_obj[0] = args;
44525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44526 if (!SWIG_IsOK(res1)) {
44527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44528 }
44529 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44530 {
44531 PyThreadState* __tstate = wxPyBeginAllowThreads();
44532 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44533 wxPyEndAllowThreads(__tstate);
44534 if (PyErr_Occurred()) SWIG_fail;
44535 }
44536 {
44537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44538 }
44539 return resultobj;
44540 fail:
44541 return NULL;
44542 }
44543
44544
44545 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44546 PyObject *resultobj = 0;
44547 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44548 unsigned int arg2 ;
44549 wxString result;
44550 void *argp1 = 0 ;
44551 int res1 = 0 ;
44552 unsigned int val2 ;
44553 int ecode2 = 0 ;
44554 PyObject * obj0 = 0 ;
44555 PyObject * obj1 = 0 ;
44556 char * kwnames[] = {
44557 (char *) "self",(char *) "n", NULL
44558 };
44559
44560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44562 if (!SWIG_IsOK(res1)) {
44563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44564 }
44565 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44566 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44567 if (!SWIG_IsOK(ecode2)) {
44568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44569 }
44570 arg2 = static_cast< unsigned int >(val2);
44571 {
44572 PyThreadState* __tstate = wxPyBeginAllowThreads();
44573 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44574 wxPyEndAllowThreads(__tstate);
44575 if (PyErr_Occurred()) SWIG_fail;
44576 }
44577 {
44578 #if wxUSE_UNICODE
44579 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44580 #else
44581 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44582 #endif
44583 }
44584 return resultobj;
44585 fail:
44586 return NULL;
44587 }
44588
44589
44590 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44591 PyObject *resultobj = 0;
44592 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44593 wxArrayString result;
44594 void *argp1 = 0 ;
44595 int res1 = 0 ;
44596 PyObject *swig_obj[1] ;
44597
44598 if (!args) SWIG_fail;
44599 swig_obj[0] = args;
44600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44601 if (!SWIG_IsOK(res1)) {
44602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44603 }
44604 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44605 {
44606 PyThreadState* __tstate = wxPyBeginAllowThreads();
44607 result = ((wxItemContainer const *)arg1)->GetStrings();
44608 wxPyEndAllowThreads(__tstate);
44609 if (PyErr_Occurred()) SWIG_fail;
44610 }
44611 {
44612 resultobj = wxArrayString2PyList_helper(result);
44613 }
44614 return resultobj;
44615 fail:
44616 return NULL;
44617 }
44618
44619
44620 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44621 PyObject *resultobj = 0;
44622 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44623 unsigned int arg2 ;
44624 wxString *arg3 = 0 ;
44625 void *argp1 = 0 ;
44626 int res1 = 0 ;
44627 unsigned int val2 ;
44628 int ecode2 = 0 ;
44629 bool temp3 = false ;
44630 PyObject * obj0 = 0 ;
44631 PyObject * obj1 = 0 ;
44632 PyObject * obj2 = 0 ;
44633 char * kwnames[] = {
44634 (char *) "self",(char *) "n",(char *) "s", NULL
44635 };
44636
44637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44639 if (!SWIG_IsOK(res1)) {
44640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44641 }
44642 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44643 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44644 if (!SWIG_IsOK(ecode2)) {
44645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44646 }
44647 arg2 = static_cast< unsigned int >(val2);
44648 {
44649 arg3 = wxString_in_helper(obj2);
44650 if (arg3 == NULL) SWIG_fail;
44651 temp3 = true;
44652 }
44653 {
44654 PyThreadState* __tstate = wxPyBeginAllowThreads();
44655 (arg1)->SetString(arg2,(wxString const &)*arg3);
44656 wxPyEndAllowThreads(__tstate);
44657 if (PyErr_Occurred()) SWIG_fail;
44658 }
44659 resultobj = SWIG_Py_Void();
44660 {
44661 if (temp3)
44662 delete arg3;
44663 }
44664 return resultobj;
44665 fail:
44666 {
44667 if (temp3)
44668 delete arg3;
44669 }
44670 return NULL;
44671 }
44672
44673
44674 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44675 PyObject *resultobj = 0;
44676 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44677 wxString *arg2 = 0 ;
44678 int result;
44679 void *argp1 = 0 ;
44680 int res1 = 0 ;
44681 bool temp2 = false ;
44682 PyObject * obj0 = 0 ;
44683 PyObject * obj1 = 0 ;
44684 char * kwnames[] = {
44685 (char *) "self",(char *) "s", NULL
44686 };
44687
44688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44690 if (!SWIG_IsOK(res1)) {
44691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44692 }
44693 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44694 {
44695 arg2 = wxString_in_helper(obj1);
44696 if (arg2 == NULL) SWIG_fail;
44697 temp2 = true;
44698 }
44699 {
44700 PyThreadState* __tstate = wxPyBeginAllowThreads();
44701 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44702 wxPyEndAllowThreads(__tstate);
44703 if (PyErr_Occurred()) SWIG_fail;
44704 }
44705 resultobj = SWIG_From_int(static_cast< int >(result));
44706 {
44707 if (temp2)
44708 delete arg2;
44709 }
44710 return resultobj;
44711 fail:
44712 {
44713 if (temp2)
44714 delete arg2;
44715 }
44716 return NULL;
44717 }
44718
44719
44720 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44721 PyObject *resultobj = 0;
44722 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44723 int arg2 ;
44724 void *argp1 = 0 ;
44725 int res1 = 0 ;
44726 int val2 ;
44727 int ecode2 = 0 ;
44728 PyObject * obj0 = 0 ;
44729 PyObject * obj1 = 0 ;
44730 char * kwnames[] = {
44731 (char *) "self",(char *) "n", NULL
44732 };
44733
44734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44736 if (!SWIG_IsOK(res1)) {
44737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44738 }
44739 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44740 ecode2 = SWIG_AsVal_int(obj1, &val2);
44741 if (!SWIG_IsOK(ecode2)) {
44742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44743 }
44744 arg2 = static_cast< int >(val2);
44745 {
44746 PyThreadState* __tstate = wxPyBeginAllowThreads();
44747 (arg1)->SetSelection(arg2);
44748 wxPyEndAllowThreads(__tstate);
44749 if (PyErr_Occurred()) SWIG_fail;
44750 }
44751 resultobj = SWIG_Py_Void();
44752 return resultobj;
44753 fail:
44754 return NULL;
44755 }
44756
44757
44758 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44759 PyObject *resultobj = 0;
44760 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44761 int result;
44762 void *argp1 = 0 ;
44763 int res1 = 0 ;
44764 PyObject *swig_obj[1] ;
44765
44766 if (!args) SWIG_fail;
44767 swig_obj[0] = args;
44768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44769 if (!SWIG_IsOK(res1)) {
44770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44771 }
44772 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44773 {
44774 PyThreadState* __tstate = wxPyBeginAllowThreads();
44775 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44776 wxPyEndAllowThreads(__tstate);
44777 if (PyErr_Occurred()) SWIG_fail;
44778 }
44779 resultobj = SWIG_From_int(static_cast< int >(result));
44780 return resultobj;
44781 fail:
44782 return NULL;
44783 }
44784
44785
44786 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44787 PyObject *resultobj = 0;
44788 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44789 wxString *arg2 = 0 ;
44790 bool result;
44791 void *argp1 = 0 ;
44792 int res1 = 0 ;
44793 bool temp2 = false ;
44794 PyObject * obj0 = 0 ;
44795 PyObject * obj1 = 0 ;
44796 char * kwnames[] = {
44797 (char *) "self",(char *) "s", NULL
44798 };
44799
44800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44802 if (!SWIG_IsOK(res1)) {
44803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44804 }
44805 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44806 {
44807 arg2 = wxString_in_helper(obj1);
44808 if (arg2 == NULL) SWIG_fail;
44809 temp2 = true;
44810 }
44811 {
44812 PyThreadState* __tstate = wxPyBeginAllowThreads();
44813 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44814 wxPyEndAllowThreads(__tstate);
44815 if (PyErr_Occurred()) SWIG_fail;
44816 }
44817 {
44818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44819 }
44820 {
44821 if (temp2)
44822 delete arg2;
44823 }
44824 return resultobj;
44825 fail:
44826 {
44827 if (temp2)
44828 delete arg2;
44829 }
44830 return NULL;
44831 }
44832
44833
44834 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44835 PyObject *resultobj = 0;
44836 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44837 wxString result;
44838 void *argp1 = 0 ;
44839 int res1 = 0 ;
44840 PyObject *swig_obj[1] ;
44841
44842 if (!args) SWIG_fail;
44843 swig_obj[0] = args;
44844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44845 if (!SWIG_IsOK(res1)) {
44846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44847 }
44848 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44849 {
44850 PyThreadState* __tstate = wxPyBeginAllowThreads();
44851 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44852 wxPyEndAllowThreads(__tstate);
44853 if (PyErr_Occurred()) SWIG_fail;
44854 }
44855 {
44856 #if wxUSE_UNICODE
44857 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44858 #else
44859 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44860 #endif
44861 }
44862 return resultobj;
44863 fail:
44864 return NULL;
44865 }
44866
44867
44868 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44869 PyObject *resultobj = 0;
44870 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44871 int arg2 ;
44872 void *argp1 = 0 ;
44873 int res1 = 0 ;
44874 int val2 ;
44875 int ecode2 = 0 ;
44876 PyObject * obj0 = 0 ;
44877 PyObject * obj1 = 0 ;
44878 char * kwnames[] = {
44879 (char *) "self",(char *) "n", NULL
44880 };
44881
44882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44884 if (!SWIG_IsOK(res1)) {
44885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44886 }
44887 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44888 ecode2 = SWIG_AsVal_int(obj1, &val2);
44889 if (!SWIG_IsOK(ecode2)) {
44890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44891 }
44892 arg2 = static_cast< int >(val2);
44893 {
44894 PyThreadState* __tstate = wxPyBeginAllowThreads();
44895 (arg1)->Select(arg2);
44896 wxPyEndAllowThreads(__tstate);
44897 if (PyErr_Occurred()) SWIG_fail;
44898 }
44899 resultobj = SWIG_Py_Void();
44900 return resultobj;
44901 fail:
44902 return NULL;
44903 }
44904
44905
44906 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44907 PyObject *obj;
44908 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44909 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44910 return SWIG_Py_Void();
44911 }
44912
44913 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44914 PyObject *obj;
44915 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44916 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44917 return SWIG_Py_Void();
44918 }
44919
44920 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44921 PyObject *resultobj = 0;
44922 wxSizerItem *result = 0 ;
44923
44924 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44925 {
44926 PyThreadState* __tstate = wxPyBeginAllowThreads();
44927 result = (wxSizerItem *)new wxSizerItem();
44928 wxPyEndAllowThreads(__tstate);
44929 if (PyErr_Occurred()) SWIG_fail;
44930 }
44931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44932 return resultobj;
44933 fail:
44934 return NULL;
44935 }
44936
44937
44938 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44939 PyObject *resultobj = 0;
44940 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44941 void *argp1 = 0 ;
44942 int res1 = 0 ;
44943 PyObject *swig_obj[1] ;
44944
44945 if (!args) SWIG_fail;
44946 swig_obj[0] = args;
44947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44948 if (!SWIG_IsOK(res1)) {
44949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44950 }
44951 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44952 {
44953 PyThreadState* __tstate = wxPyBeginAllowThreads();
44954 delete arg1;
44955
44956 wxPyEndAllowThreads(__tstate);
44957 if (PyErr_Occurred()) SWIG_fail;
44958 }
44959 resultobj = SWIG_Py_Void();
44960 return resultobj;
44961 fail:
44962 return NULL;
44963 }
44964
44965
44966 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44967 PyObject *resultobj = 0;
44968 wxWindow *arg1 = (wxWindow *) 0 ;
44969 int arg2 ;
44970 int arg3 ;
44971 int arg4 ;
44972 PyObject *arg5 = (PyObject *) NULL ;
44973 wxSizerItem *result = 0 ;
44974 void *argp1 = 0 ;
44975 int res1 = 0 ;
44976 int val2 ;
44977 int ecode2 = 0 ;
44978 int val3 ;
44979 int ecode3 = 0 ;
44980 int val4 ;
44981 int ecode4 = 0 ;
44982 PyObject * obj0 = 0 ;
44983 PyObject * obj1 = 0 ;
44984 PyObject * obj2 = 0 ;
44985 PyObject * obj3 = 0 ;
44986 PyObject * obj4 = 0 ;
44987 char * kwnames[] = {
44988 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44989 };
44990
44991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44993 if (!SWIG_IsOK(res1)) {
44994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44995 }
44996 arg1 = reinterpret_cast< wxWindow * >(argp1);
44997 ecode2 = SWIG_AsVal_int(obj1, &val2);
44998 if (!SWIG_IsOK(ecode2)) {
44999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45000 }
45001 arg2 = static_cast< int >(val2);
45002 ecode3 = SWIG_AsVal_int(obj2, &val3);
45003 if (!SWIG_IsOK(ecode3)) {
45004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45005 }
45006 arg3 = static_cast< int >(val3);
45007 ecode4 = SWIG_AsVal_int(obj3, &val4);
45008 if (!SWIG_IsOK(ecode4)) {
45009 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45010 }
45011 arg4 = static_cast< int >(val4);
45012 if (obj4) {
45013 arg5 = obj4;
45014 }
45015 {
45016 PyThreadState* __tstate = wxPyBeginAllowThreads();
45017 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45018 wxPyEndAllowThreads(__tstate);
45019 if (PyErr_Occurred()) SWIG_fail;
45020 }
45021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45022 return resultobj;
45023 fail:
45024 return NULL;
45025 }
45026
45027
45028 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45029 PyObject *resultobj = 0;
45030 int arg1 ;
45031 int arg2 ;
45032 int arg3 ;
45033 int arg4 ;
45034 int arg5 ;
45035 PyObject *arg6 = (PyObject *) NULL ;
45036 wxSizerItem *result = 0 ;
45037 int val1 ;
45038 int ecode1 = 0 ;
45039 int val2 ;
45040 int ecode2 = 0 ;
45041 int val3 ;
45042 int ecode3 = 0 ;
45043 int val4 ;
45044 int ecode4 = 0 ;
45045 int val5 ;
45046 int ecode5 = 0 ;
45047 PyObject * obj0 = 0 ;
45048 PyObject * obj1 = 0 ;
45049 PyObject * obj2 = 0 ;
45050 PyObject * obj3 = 0 ;
45051 PyObject * obj4 = 0 ;
45052 PyObject * obj5 = 0 ;
45053 char * kwnames[] = {
45054 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45055 };
45056
45057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45058 ecode1 = SWIG_AsVal_int(obj0, &val1);
45059 if (!SWIG_IsOK(ecode1)) {
45060 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45061 }
45062 arg1 = static_cast< int >(val1);
45063 ecode2 = SWIG_AsVal_int(obj1, &val2);
45064 if (!SWIG_IsOK(ecode2)) {
45065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', 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 '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45071 }
45072 arg3 = static_cast< int >(val3);
45073 ecode4 = SWIG_AsVal_int(obj3, &val4);
45074 if (!SWIG_IsOK(ecode4)) {
45075 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45076 }
45077 arg4 = static_cast< int >(val4);
45078 ecode5 = SWIG_AsVal_int(obj4, &val5);
45079 if (!SWIG_IsOK(ecode5)) {
45080 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45081 }
45082 arg5 = static_cast< int >(val5);
45083 if (obj5) {
45084 arg6 = obj5;
45085 }
45086 {
45087 PyThreadState* __tstate = wxPyBeginAllowThreads();
45088 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45089 wxPyEndAllowThreads(__tstate);
45090 if (PyErr_Occurred()) SWIG_fail;
45091 }
45092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45093 return resultobj;
45094 fail:
45095 return NULL;
45096 }
45097
45098
45099 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45100 PyObject *resultobj = 0;
45101 wxSizer *arg1 = (wxSizer *) 0 ;
45102 int arg2 ;
45103 int arg3 ;
45104 int arg4 ;
45105 PyObject *arg5 = (PyObject *) NULL ;
45106 wxSizerItem *result = 0 ;
45107 int res1 = 0 ;
45108 int val2 ;
45109 int ecode2 = 0 ;
45110 int val3 ;
45111 int ecode3 = 0 ;
45112 int val4 ;
45113 int ecode4 = 0 ;
45114 PyObject * obj0 = 0 ;
45115 PyObject * obj1 = 0 ;
45116 PyObject * obj2 = 0 ;
45117 PyObject * obj3 = 0 ;
45118 PyObject * obj4 = 0 ;
45119 char * kwnames[] = {
45120 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45121 };
45122
45123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45124 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45125 if (!SWIG_IsOK(res1)) {
45126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45127 }
45128 ecode2 = SWIG_AsVal_int(obj1, &val2);
45129 if (!SWIG_IsOK(ecode2)) {
45130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45131 }
45132 arg2 = static_cast< int >(val2);
45133 ecode3 = SWIG_AsVal_int(obj2, &val3);
45134 if (!SWIG_IsOK(ecode3)) {
45135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45136 }
45137 arg3 = static_cast< int >(val3);
45138 ecode4 = SWIG_AsVal_int(obj3, &val4);
45139 if (!SWIG_IsOK(ecode4)) {
45140 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45141 }
45142 arg4 = static_cast< int >(val4);
45143 if (obj4) {
45144 arg5 = obj4;
45145 }
45146 {
45147 PyThreadState* __tstate = wxPyBeginAllowThreads();
45148 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45149 wxPyEndAllowThreads(__tstate);
45150 if (PyErr_Occurred()) SWIG_fail;
45151 }
45152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45153 return resultobj;
45154 fail:
45155 return NULL;
45156 }
45157
45158
45159 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45160 PyObject *resultobj = 0;
45161 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45162 void *argp1 = 0 ;
45163 int res1 = 0 ;
45164 PyObject *swig_obj[1] ;
45165
45166 if (!args) SWIG_fail;
45167 swig_obj[0] = args;
45168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45169 if (!SWIG_IsOK(res1)) {
45170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45171 }
45172 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45173 {
45174 PyThreadState* __tstate = wxPyBeginAllowThreads();
45175 (arg1)->DeleteWindows();
45176 wxPyEndAllowThreads(__tstate);
45177 if (PyErr_Occurred()) SWIG_fail;
45178 }
45179 resultobj = SWIG_Py_Void();
45180 return resultobj;
45181 fail:
45182 return NULL;
45183 }
45184
45185
45186 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45187 PyObject *resultobj = 0;
45188 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45189 void *argp1 = 0 ;
45190 int res1 = 0 ;
45191 PyObject *swig_obj[1] ;
45192
45193 if (!args) SWIG_fail;
45194 swig_obj[0] = args;
45195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45196 if (!SWIG_IsOK(res1)) {
45197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45198 }
45199 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45200 {
45201 PyThreadState* __tstate = wxPyBeginAllowThreads();
45202 (arg1)->DetachSizer();
45203 wxPyEndAllowThreads(__tstate);
45204 if (PyErr_Occurred()) SWIG_fail;
45205 }
45206 resultobj = SWIG_Py_Void();
45207 return resultobj;
45208 fail:
45209 return NULL;
45210 }
45211
45212
45213 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45214 PyObject *resultobj = 0;
45215 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45216 wxSize result;
45217 void *argp1 = 0 ;
45218 int res1 = 0 ;
45219 PyObject *swig_obj[1] ;
45220
45221 if (!args) SWIG_fail;
45222 swig_obj[0] = args;
45223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45224 if (!SWIG_IsOK(res1)) {
45225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45226 }
45227 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45228 {
45229 PyThreadState* __tstate = wxPyBeginAllowThreads();
45230 result = (arg1)->GetSize();
45231 wxPyEndAllowThreads(__tstate);
45232 if (PyErr_Occurred()) SWIG_fail;
45233 }
45234 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45235 return resultobj;
45236 fail:
45237 return NULL;
45238 }
45239
45240
45241 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45242 PyObject *resultobj = 0;
45243 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45244 wxSize result;
45245 void *argp1 = 0 ;
45246 int res1 = 0 ;
45247 PyObject *swig_obj[1] ;
45248
45249 if (!args) SWIG_fail;
45250 swig_obj[0] = args;
45251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45252 if (!SWIG_IsOK(res1)) {
45253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45254 }
45255 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45256 {
45257 PyThreadState* __tstate = wxPyBeginAllowThreads();
45258 result = (arg1)->CalcMin();
45259 wxPyEndAllowThreads(__tstate);
45260 if (PyErr_Occurred()) SWIG_fail;
45261 }
45262 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45263 return resultobj;
45264 fail:
45265 return NULL;
45266 }
45267
45268
45269 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45270 PyObject *resultobj = 0;
45271 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45272 wxPoint *arg2 = 0 ;
45273 wxSize *arg3 = 0 ;
45274 void *argp1 = 0 ;
45275 int res1 = 0 ;
45276 wxPoint temp2 ;
45277 wxSize temp3 ;
45278 PyObject * obj0 = 0 ;
45279 PyObject * obj1 = 0 ;
45280 PyObject * obj2 = 0 ;
45281 char * kwnames[] = {
45282 (char *) "self",(char *) "pos",(char *) "size", NULL
45283 };
45284
45285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45287 if (!SWIG_IsOK(res1)) {
45288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45289 }
45290 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45291 {
45292 arg2 = &temp2;
45293 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45294 }
45295 {
45296 arg3 = &temp3;
45297 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45298 }
45299 {
45300 PyThreadState* __tstate = wxPyBeginAllowThreads();
45301 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45302 wxPyEndAllowThreads(__tstate);
45303 if (PyErr_Occurred()) SWIG_fail;
45304 }
45305 resultobj = SWIG_Py_Void();
45306 return resultobj;
45307 fail:
45308 return NULL;
45309 }
45310
45311
45312 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45313 PyObject *resultobj = 0;
45314 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45315 wxSize result;
45316 void *argp1 = 0 ;
45317 int res1 = 0 ;
45318 PyObject *swig_obj[1] ;
45319
45320 if (!args) SWIG_fail;
45321 swig_obj[0] = args;
45322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45323 if (!SWIG_IsOK(res1)) {
45324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45325 }
45326 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45327 {
45328 PyThreadState* __tstate = wxPyBeginAllowThreads();
45329 result = (arg1)->GetMinSize();
45330 wxPyEndAllowThreads(__tstate);
45331 if (PyErr_Occurred()) SWIG_fail;
45332 }
45333 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45334 return resultobj;
45335 fail:
45336 return NULL;
45337 }
45338
45339
45340 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45341 PyObject *resultobj = 0;
45342 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45343 wxSize result;
45344 void *argp1 = 0 ;
45345 int res1 = 0 ;
45346 PyObject *swig_obj[1] ;
45347
45348 if (!args) SWIG_fail;
45349 swig_obj[0] = args;
45350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45351 if (!SWIG_IsOK(res1)) {
45352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45353 }
45354 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45355 {
45356 PyThreadState* __tstate = wxPyBeginAllowThreads();
45357 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45358 wxPyEndAllowThreads(__tstate);
45359 if (PyErr_Occurred()) SWIG_fail;
45360 }
45361 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45362 return resultobj;
45363 fail:
45364 return NULL;
45365 }
45366
45367
45368 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45369 PyObject *resultobj = 0;
45370 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45371 int arg2 ;
45372 int arg3 ;
45373 void *argp1 = 0 ;
45374 int res1 = 0 ;
45375 int val2 ;
45376 int ecode2 = 0 ;
45377 int val3 ;
45378 int ecode3 = 0 ;
45379 PyObject * obj0 = 0 ;
45380 PyObject * obj1 = 0 ;
45381 PyObject * obj2 = 0 ;
45382 char * kwnames[] = {
45383 (char *) "self",(char *) "x",(char *) "y", NULL
45384 };
45385
45386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45388 if (!SWIG_IsOK(res1)) {
45389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45390 }
45391 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45392 ecode2 = SWIG_AsVal_int(obj1, &val2);
45393 if (!SWIG_IsOK(ecode2)) {
45394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45395 }
45396 arg2 = static_cast< int >(val2);
45397 ecode3 = SWIG_AsVal_int(obj2, &val3);
45398 if (!SWIG_IsOK(ecode3)) {
45399 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45400 }
45401 arg3 = static_cast< int >(val3);
45402 {
45403 PyThreadState* __tstate = wxPyBeginAllowThreads();
45404 (arg1)->SetInitSize(arg2,arg3);
45405 wxPyEndAllowThreads(__tstate);
45406 if (PyErr_Occurred()) SWIG_fail;
45407 }
45408 resultobj = SWIG_Py_Void();
45409 return resultobj;
45410 fail:
45411 return NULL;
45412 }
45413
45414
45415 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45416 PyObject *resultobj = 0;
45417 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45418 int arg2 ;
45419 int arg3 ;
45420 void *argp1 = 0 ;
45421 int res1 = 0 ;
45422 int val2 ;
45423 int ecode2 = 0 ;
45424 int val3 ;
45425 int ecode3 = 0 ;
45426 PyObject * obj0 = 0 ;
45427 PyObject * obj1 = 0 ;
45428 PyObject * obj2 = 0 ;
45429 char * kwnames[] = {
45430 (char *) "self",(char *) "width",(char *) "height", NULL
45431 };
45432
45433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) 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_SetRatioWH" "', 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_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45442 }
45443 arg2 = static_cast< int >(val2);
45444 ecode3 = SWIG_AsVal_int(obj2, &val3);
45445 if (!SWIG_IsOK(ecode3)) {
45446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45447 }
45448 arg3 = static_cast< int >(val3);
45449 {
45450 PyThreadState* __tstate = wxPyBeginAllowThreads();
45451 (arg1)->SetRatio(arg2,arg3);
45452 wxPyEndAllowThreads(__tstate);
45453 if (PyErr_Occurred()) SWIG_fail;
45454 }
45455 resultobj = SWIG_Py_Void();
45456 return resultobj;
45457 fail:
45458 return NULL;
45459 }
45460
45461
45462 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45463 PyObject *resultobj = 0;
45464 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45465 wxSize *arg2 = 0 ;
45466 void *argp1 = 0 ;
45467 int res1 = 0 ;
45468 wxSize temp2 ;
45469 PyObject * obj0 = 0 ;
45470 PyObject * obj1 = 0 ;
45471 char * kwnames[] = {
45472 (char *) "self",(char *) "size", NULL
45473 };
45474
45475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45477 if (!SWIG_IsOK(res1)) {
45478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45479 }
45480 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45481 {
45482 arg2 = &temp2;
45483 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45484 }
45485 {
45486 PyThreadState* __tstate = wxPyBeginAllowThreads();
45487 (arg1)->SetRatio((wxSize const &)*arg2);
45488 wxPyEndAllowThreads(__tstate);
45489 if (PyErr_Occurred()) SWIG_fail;
45490 }
45491 resultobj = SWIG_Py_Void();
45492 return resultobj;
45493 fail:
45494 return NULL;
45495 }
45496
45497
45498 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45499 PyObject *resultobj = 0;
45500 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45501 float arg2 ;
45502 void *argp1 = 0 ;
45503 int res1 = 0 ;
45504 float val2 ;
45505 int ecode2 = 0 ;
45506 PyObject * obj0 = 0 ;
45507 PyObject * obj1 = 0 ;
45508 char * kwnames[] = {
45509 (char *) "self",(char *) "ratio", NULL
45510 };
45511
45512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45514 if (!SWIG_IsOK(res1)) {
45515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45516 }
45517 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45518 ecode2 = SWIG_AsVal_float(obj1, &val2);
45519 if (!SWIG_IsOK(ecode2)) {
45520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45521 }
45522 arg2 = static_cast< float >(val2);
45523 {
45524 PyThreadState* __tstate = wxPyBeginAllowThreads();
45525 (arg1)->SetRatio(arg2);
45526 wxPyEndAllowThreads(__tstate);
45527 if (PyErr_Occurred()) SWIG_fail;
45528 }
45529 resultobj = SWIG_Py_Void();
45530 return resultobj;
45531 fail:
45532 return NULL;
45533 }
45534
45535
45536 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45537 PyObject *resultobj = 0;
45538 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45539 float result;
45540 void *argp1 = 0 ;
45541 int res1 = 0 ;
45542 PyObject *swig_obj[1] ;
45543
45544 if (!args) SWIG_fail;
45545 swig_obj[0] = args;
45546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45547 if (!SWIG_IsOK(res1)) {
45548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45549 }
45550 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45551 {
45552 PyThreadState* __tstate = wxPyBeginAllowThreads();
45553 result = (float)(arg1)->GetRatio();
45554 wxPyEndAllowThreads(__tstate);
45555 if (PyErr_Occurred()) SWIG_fail;
45556 }
45557 resultobj = SWIG_From_float(static_cast< float >(result));
45558 return resultobj;
45559 fail:
45560 return NULL;
45561 }
45562
45563
45564 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45565 PyObject *resultobj = 0;
45566 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45567 wxRect result;
45568 void *argp1 = 0 ;
45569 int res1 = 0 ;
45570 PyObject *swig_obj[1] ;
45571
45572 if (!args) SWIG_fail;
45573 swig_obj[0] = args;
45574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45575 if (!SWIG_IsOK(res1)) {
45576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45577 }
45578 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45579 {
45580 PyThreadState* __tstate = wxPyBeginAllowThreads();
45581 result = (arg1)->GetRect();
45582 wxPyEndAllowThreads(__tstate);
45583 if (PyErr_Occurred()) SWIG_fail;
45584 }
45585 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45586 return resultobj;
45587 fail:
45588 return NULL;
45589 }
45590
45591
45592 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45593 PyObject *resultobj = 0;
45594 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45595 bool result;
45596 void *argp1 = 0 ;
45597 int res1 = 0 ;
45598 PyObject *swig_obj[1] ;
45599
45600 if (!args) SWIG_fail;
45601 swig_obj[0] = args;
45602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45603 if (!SWIG_IsOK(res1)) {
45604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45605 }
45606 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45607 {
45608 PyThreadState* __tstate = wxPyBeginAllowThreads();
45609 result = (bool)(arg1)->IsWindow();
45610 wxPyEndAllowThreads(__tstate);
45611 if (PyErr_Occurred()) SWIG_fail;
45612 }
45613 {
45614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45615 }
45616 return resultobj;
45617 fail:
45618 return NULL;
45619 }
45620
45621
45622 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45623 PyObject *resultobj = 0;
45624 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45625 bool result;
45626 void *argp1 = 0 ;
45627 int res1 = 0 ;
45628 PyObject *swig_obj[1] ;
45629
45630 if (!args) SWIG_fail;
45631 swig_obj[0] = args;
45632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45633 if (!SWIG_IsOK(res1)) {
45634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45635 }
45636 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45637 {
45638 PyThreadState* __tstate = wxPyBeginAllowThreads();
45639 result = (bool)(arg1)->IsSizer();
45640 wxPyEndAllowThreads(__tstate);
45641 if (PyErr_Occurred()) SWIG_fail;
45642 }
45643 {
45644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45645 }
45646 return resultobj;
45647 fail:
45648 return NULL;
45649 }
45650
45651
45652 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45653 PyObject *resultobj = 0;
45654 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45655 bool result;
45656 void *argp1 = 0 ;
45657 int res1 = 0 ;
45658 PyObject *swig_obj[1] ;
45659
45660 if (!args) SWIG_fail;
45661 swig_obj[0] = args;
45662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45663 if (!SWIG_IsOK(res1)) {
45664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45665 }
45666 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45667 {
45668 PyThreadState* __tstate = wxPyBeginAllowThreads();
45669 result = (bool)(arg1)->IsSpacer();
45670 wxPyEndAllowThreads(__tstate);
45671 if (PyErr_Occurred()) SWIG_fail;
45672 }
45673 {
45674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45675 }
45676 return resultobj;
45677 fail:
45678 return NULL;
45679 }
45680
45681
45682 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45683 PyObject *resultobj = 0;
45684 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45685 int arg2 ;
45686 void *argp1 = 0 ;
45687 int res1 = 0 ;
45688 int val2 ;
45689 int ecode2 = 0 ;
45690 PyObject * obj0 = 0 ;
45691 PyObject * obj1 = 0 ;
45692 char * kwnames[] = {
45693 (char *) "self",(char *) "proportion", NULL
45694 };
45695
45696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45698 if (!SWIG_IsOK(res1)) {
45699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45700 }
45701 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45702 ecode2 = SWIG_AsVal_int(obj1, &val2);
45703 if (!SWIG_IsOK(ecode2)) {
45704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45705 }
45706 arg2 = static_cast< int >(val2);
45707 {
45708 PyThreadState* __tstate = wxPyBeginAllowThreads();
45709 (arg1)->SetProportion(arg2);
45710 wxPyEndAllowThreads(__tstate);
45711 if (PyErr_Occurred()) SWIG_fail;
45712 }
45713 resultobj = SWIG_Py_Void();
45714 return resultobj;
45715 fail:
45716 return NULL;
45717 }
45718
45719
45720 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45721 PyObject *resultobj = 0;
45722 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45723 int result;
45724 void *argp1 = 0 ;
45725 int res1 = 0 ;
45726 PyObject *swig_obj[1] ;
45727
45728 if (!args) SWIG_fail;
45729 swig_obj[0] = args;
45730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45731 if (!SWIG_IsOK(res1)) {
45732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45733 }
45734 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45735 {
45736 PyThreadState* __tstate = wxPyBeginAllowThreads();
45737 result = (int)(arg1)->GetProportion();
45738 wxPyEndAllowThreads(__tstate);
45739 if (PyErr_Occurred()) SWIG_fail;
45740 }
45741 resultobj = SWIG_From_int(static_cast< int >(result));
45742 return resultobj;
45743 fail:
45744 return NULL;
45745 }
45746
45747
45748 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45749 PyObject *resultobj = 0;
45750 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45751 int arg2 ;
45752 void *argp1 = 0 ;
45753 int res1 = 0 ;
45754 int val2 ;
45755 int ecode2 = 0 ;
45756 PyObject * obj0 = 0 ;
45757 PyObject * obj1 = 0 ;
45758 char * kwnames[] = {
45759 (char *) "self",(char *) "flag", NULL
45760 };
45761
45762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45764 if (!SWIG_IsOK(res1)) {
45765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45766 }
45767 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45768 ecode2 = SWIG_AsVal_int(obj1, &val2);
45769 if (!SWIG_IsOK(ecode2)) {
45770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45771 }
45772 arg2 = static_cast< int >(val2);
45773 {
45774 PyThreadState* __tstate = wxPyBeginAllowThreads();
45775 (arg1)->SetFlag(arg2);
45776 wxPyEndAllowThreads(__tstate);
45777 if (PyErr_Occurred()) SWIG_fail;
45778 }
45779 resultobj = SWIG_Py_Void();
45780 return resultobj;
45781 fail:
45782 return NULL;
45783 }
45784
45785
45786 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45787 PyObject *resultobj = 0;
45788 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45789 int result;
45790 void *argp1 = 0 ;
45791 int res1 = 0 ;
45792 PyObject *swig_obj[1] ;
45793
45794 if (!args) SWIG_fail;
45795 swig_obj[0] = args;
45796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45797 if (!SWIG_IsOK(res1)) {
45798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45799 }
45800 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45801 {
45802 PyThreadState* __tstate = wxPyBeginAllowThreads();
45803 result = (int)(arg1)->GetFlag();
45804 wxPyEndAllowThreads(__tstate);
45805 if (PyErr_Occurred()) SWIG_fail;
45806 }
45807 resultobj = SWIG_From_int(static_cast< int >(result));
45808 return resultobj;
45809 fail:
45810 return NULL;
45811 }
45812
45813
45814 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45815 PyObject *resultobj = 0;
45816 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45817 int arg2 ;
45818 void *argp1 = 0 ;
45819 int res1 = 0 ;
45820 int val2 ;
45821 int ecode2 = 0 ;
45822 PyObject * obj0 = 0 ;
45823 PyObject * obj1 = 0 ;
45824 char * kwnames[] = {
45825 (char *) "self",(char *) "border", NULL
45826 };
45827
45828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45830 if (!SWIG_IsOK(res1)) {
45831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45832 }
45833 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45834 ecode2 = SWIG_AsVal_int(obj1, &val2);
45835 if (!SWIG_IsOK(ecode2)) {
45836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45837 }
45838 arg2 = static_cast< int >(val2);
45839 {
45840 PyThreadState* __tstate = wxPyBeginAllowThreads();
45841 (arg1)->SetBorder(arg2);
45842 wxPyEndAllowThreads(__tstate);
45843 if (PyErr_Occurred()) SWIG_fail;
45844 }
45845 resultobj = SWIG_Py_Void();
45846 return resultobj;
45847 fail:
45848 return NULL;
45849 }
45850
45851
45852 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45853 PyObject *resultobj = 0;
45854 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45855 int result;
45856 void *argp1 = 0 ;
45857 int res1 = 0 ;
45858 PyObject *swig_obj[1] ;
45859
45860 if (!args) SWIG_fail;
45861 swig_obj[0] = args;
45862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45863 if (!SWIG_IsOK(res1)) {
45864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45865 }
45866 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45867 {
45868 PyThreadState* __tstate = wxPyBeginAllowThreads();
45869 result = (int)(arg1)->GetBorder();
45870 wxPyEndAllowThreads(__tstate);
45871 if (PyErr_Occurred()) SWIG_fail;
45872 }
45873 resultobj = SWIG_From_int(static_cast< int >(result));
45874 return resultobj;
45875 fail:
45876 return NULL;
45877 }
45878
45879
45880 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45881 PyObject *resultobj = 0;
45882 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45883 wxWindow *result = 0 ;
45884 void *argp1 = 0 ;
45885 int res1 = 0 ;
45886 PyObject *swig_obj[1] ;
45887
45888 if (!args) SWIG_fail;
45889 swig_obj[0] = args;
45890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45891 if (!SWIG_IsOK(res1)) {
45892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45893 }
45894 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45895 {
45896 PyThreadState* __tstate = wxPyBeginAllowThreads();
45897 result = (wxWindow *)(arg1)->GetWindow();
45898 wxPyEndAllowThreads(__tstate);
45899 if (PyErr_Occurred()) SWIG_fail;
45900 }
45901 {
45902 resultobj = wxPyMake_wxObject(result, 0);
45903 }
45904 return resultobj;
45905 fail:
45906 return NULL;
45907 }
45908
45909
45910 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45911 PyObject *resultobj = 0;
45912 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45913 wxWindow *arg2 = (wxWindow *) 0 ;
45914 void *argp1 = 0 ;
45915 int res1 = 0 ;
45916 void *argp2 = 0 ;
45917 int res2 = 0 ;
45918 PyObject * obj0 = 0 ;
45919 PyObject * obj1 = 0 ;
45920 char * kwnames[] = {
45921 (char *) "self",(char *) "window", NULL
45922 };
45923
45924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45926 if (!SWIG_IsOK(res1)) {
45927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45928 }
45929 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45930 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45931 if (!SWIG_IsOK(res2)) {
45932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45933 }
45934 arg2 = reinterpret_cast< wxWindow * >(argp2);
45935 {
45936 PyThreadState* __tstate = wxPyBeginAllowThreads();
45937 (arg1)->SetWindow(arg2);
45938 wxPyEndAllowThreads(__tstate);
45939 if (PyErr_Occurred()) SWIG_fail;
45940 }
45941 resultobj = SWIG_Py_Void();
45942 return resultobj;
45943 fail:
45944 return NULL;
45945 }
45946
45947
45948 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45949 PyObject *resultobj = 0;
45950 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45951 wxSizer *result = 0 ;
45952 void *argp1 = 0 ;
45953 int res1 = 0 ;
45954 PyObject *swig_obj[1] ;
45955
45956 if (!args) SWIG_fail;
45957 swig_obj[0] = args;
45958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45959 if (!SWIG_IsOK(res1)) {
45960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45961 }
45962 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45963 {
45964 PyThreadState* __tstate = wxPyBeginAllowThreads();
45965 result = (wxSizer *)(arg1)->GetSizer();
45966 wxPyEndAllowThreads(__tstate);
45967 if (PyErr_Occurred()) SWIG_fail;
45968 }
45969 {
45970 resultobj = wxPyMake_wxObject(result, (bool)0);
45971 }
45972 return resultobj;
45973 fail:
45974 return NULL;
45975 }
45976
45977
45978 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45979 PyObject *resultobj = 0;
45980 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45981 wxSizer *arg2 = (wxSizer *) 0 ;
45982 void *argp1 = 0 ;
45983 int res1 = 0 ;
45984 int res2 = 0 ;
45985 PyObject * obj0 = 0 ;
45986 PyObject * obj1 = 0 ;
45987 char * kwnames[] = {
45988 (char *) "self",(char *) "sizer", NULL
45989 };
45990
45991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45993 if (!SWIG_IsOK(res1)) {
45994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45995 }
45996 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45997 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45998 if (!SWIG_IsOK(res2)) {
45999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46000 }
46001 {
46002 PyThreadState* __tstate = wxPyBeginAllowThreads();
46003 (arg1)->SetSizer(arg2);
46004 wxPyEndAllowThreads(__tstate);
46005 if (PyErr_Occurred()) SWIG_fail;
46006 }
46007 resultobj = SWIG_Py_Void();
46008 return resultobj;
46009 fail:
46010 return NULL;
46011 }
46012
46013
46014 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46015 PyObject *resultobj = 0;
46016 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46017 wxSize *result = 0 ;
46018 void *argp1 = 0 ;
46019 int res1 = 0 ;
46020 PyObject *swig_obj[1] ;
46021
46022 if (!args) SWIG_fail;
46023 swig_obj[0] = args;
46024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46025 if (!SWIG_IsOK(res1)) {
46026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46027 }
46028 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46029 {
46030 PyThreadState* __tstate = wxPyBeginAllowThreads();
46031 {
46032 wxSize const &_result_ref = (arg1)->GetSpacer();
46033 result = (wxSize *) &_result_ref;
46034 }
46035 wxPyEndAllowThreads(__tstate);
46036 if (PyErr_Occurred()) SWIG_fail;
46037 }
46038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46039 return resultobj;
46040 fail:
46041 return NULL;
46042 }
46043
46044
46045 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46046 PyObject *resultobj = 0;
46047 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46048 wxSize *arg2 = 0 ;
46049 void *argp1 = 0 ;
46050 int res1 = 0 ;
46051 wxSize temp2 ;
46052 PyObject * obj0 = 0 ;
46053 PyObject * obj1 = 0 ;
46054 char * kwnames[] = {
46055 (char *) "self",(char *) "size", NULL
46056 };
46057
46058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46060 if (!SWIG_IsOK(res1)) {
46061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46062 }
46063 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46064 {
46065 arg2 = &temp2;
46066 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46067 }
46068 {
46069 PyThreadState* __tstate = wxPyBeginAllowThreads();
46070 (arg1)->SetSpacer((wxSize const &)*arg2);
46071 wxPyEndAllowThreads(__tstate);
46072 if (PyErr_Occurred()) SWIG_fail;
46073 }
46074 resultobj = SWIG_Py_Void();
46075 return resultobj;
46076 fail:
46077 return NULL;
46078 }
46079
46080
46081 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46082 PyObject *resultobj = 0;
46083 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46084 bool arg2 ;
46085 void *argp1 = 0 ;
46086 int res1 = 0 ;
46087 bool val2 ;
46088 int ecode2 = 0 ;
46089 PyObject * obj0 = 0 ;
46090 PyObject * obj1 = 0 ;
46091 char * kwnames[] = {
46092 (char *) "self",(char *) "show", NULL
46093 };
46094
46095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46097 if (!SWIG_IsOK(res1)) {
46098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46099 }
46100 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46101 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46102 if (!SWIG_IsOK(ecode2)) {
46103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46104 }
46105 arg2 = static_cast< bool >(val2);
46106 {
46107 PyThreadState* __tstate = wxPyBeginAllowThreads();
46108 (arg1)->Show(arg2);
46109 wxPyEndAllowThreads(__tstate);
46110 if (PyErr_Occurred()) SWIG_fail;
46111 }
46112 resultobj = SWIG_Py_Void();
46113 return resultobj;
46114 fail:
46115 return NULL;
46116 }
46117
46118
46119 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46120 PyObject *resultobj = 0;
46121 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46122 bool result;
46123 void *argp1 = 0 ;
46124 int res1 = 0 ;
46125 PyObject *swig_obj[1] ;
46126
46127 if (!args) SWIG_fail;
46128 swig_obj[0] = args;
46129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46130 if (!SWIG_IsOK(res1)) {
46131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46132 }
46133 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46134 {
46135 PyThreadState* __tstate = wxPyBeginAllowThreads();
46136 result = (bool)(arg1)->IsShown();
46137 wxPyEndAllowThreads(__tstate);
46138 if (PyErr_Occurred()) SWIG_fail;
46139 }
46140 {
46141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46142 }
46143 return resultobj;
46144 fail:
46145 return NULL;
46146 }
46147
46148
46149 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46150 PyObject *resultobj = 0;
46151 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46152 wxPoint result;
46153 void *argp1 = 0 ;
46154 int res1 = 0 ;
46155 PyObject *swig_obj[1] ;
46156
46157 if (!args) SWIG_fail;
46158 swig_obj[0] = args;
46159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46160 if (!SWIG_IsOK(res1)) {
46161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46162 }
46163 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46164 {
46165 PyThreadState* __tstate = wxPyBeginAllowThreads();
46166 result = (arg1)->GetPosition();
46167 wxPyEndAllowThreads(__tstate);
46168 if (PyErr_Occurred()) SWIG_fail;
46169 }
46170 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46171 return resultobj;
46172 fail:
46173 return NULL;
46174 }
46175
46176
46177 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46178 PyObject *resultobj = 0;
46179 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46180 PyObject *result = 0 ;
46181 void *argp1 = 0 ;
46182 int res1 = 0 ;
46183 PyObject *swig_obj[1] ;
46184
46185 if (!args) SWIG_fail;
46186 swig_obj[0] = args;
46187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46188 if (!SWIG_IsOK(res1)) {
46189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46190 }
46191 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46192 {
46193 PyThreadState* __tstate = wxPyBeginAllowThreads();
46194 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46195 wxPyEndAllowThreads(__tstate);
46196 if (PyErr_Occurred()) SWIG_fail;
46197 }
46198 resultobj = result;
46199 return resultobj;
46200 fail:
46201 return NULL;
46202 }
46203
46204
46205 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46206 PyObject *resultobj = 0;
46207 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46208 PyObject *arg2 = (PyObject *) 0 ;
46209 void *argp1 = 0 ;
46210 int res1 = 0 ;
46211 PyObject * obj0 = 0 ;
46212 PyObject * obj1 = 0 ;
46213 char * kwnames[] = {
46214 (char *) "self",(char *) "userData", NULL
46215 };
46216
46217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46219 if (!SWIG_IsOK(res1)) {
46220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46221 }
46222 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46223 arg2 = obj1;
46224 {
46225 PyThreadState* __tstate = wxPyBeginAllowThreads();
46226 wxSizerItem_SetUserData(arg1,arg2);
46227 wxPyEndAllowThreads(__tstate);
46228 if (PyErr_Occurred()) SWIG_fail;
46229 }
46230 resultobj = SWIG_Py_Void();
46231 return resultobj;
46232 fail:
46233 return NULL;
46234 }
46235
46236
46237 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46238 PyObject *obj;
46239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46240 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46241 return SWIG_Py_Void();
46242 }
46243
46244 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46245 return SWIG_Python_InitShadowInstance(args);
46246 }
46247
46248 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46249 PyObject *resultobj = 0;
46250 wxSizer *arg1 = (wxSizer *) 0 ;
46251 void *argp1 = 0 ;
46252 int res1 = 0 ;
46253 PyObject *swig_obj[1] ;
46254
46255 if (!args) SWIG_fail;
46256 swig_obj[0] = args;
46257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46258 if (!SWIG_IsOK(res1)) {
46259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46260 }
46261 arg1 = reinterpret_cast< wxSizer * >(argp1);
46262 {
46263 PyThreadState* __tstate = wxPyBeginAllowThreads();
46264 delete arg1;
46265
46266 wxPyEndAllowThreads(__tstate);
46267 if (PyErr_Occurred()) SWIG_fail;
46268 }
46269 resultobj = SWIG_Py_Void();
46270 return resultobj;
46271 fail:
46272 return NULL;
46273 }
46274
46275
46276 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46277 PyObject *resultobj = 0;
46278 wxSizer *arg1 = (wxSizer *) 0 ;
46279 PyObject *arg2 = (PyObject *) 0 ;
46280 void *argp1 = 0 ;
46281 int res1 = 0 ;
46282 PyObject * obj0 = 0 ;
46283 PyObject * obj1 = 0 ;
46284 char * kwnames[] = {
46285 (char *) "self",(char *) "_self", NULL
46286 };
46287
46288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46290 if (!SWIG_IsOK(res1)) {
46291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46292 }
46293 arg1 = reinterpret_cast< wxSizer * >(argp1);
46294 arg2 = obj1;
46295 {
46296 PyThreadState* __tstate = wxPyBeginAllowThreads();
46297 wxSizer__setOORInfo(arg1,arg2);
46298 wxPyEndAllowThreads(__tstate);
46299 if (PyErr_Occurred()) SWIG_fail;
46300 }
46301 resultobj = SWIG_Py_Void();
46302 return resultobj;
46303 fail:
46304 return NULL;
46305 }
46306
46307
46308 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46309 PyObject *resultobj = 0;
46310 wxSizer *arg1 = (wxSizer *) 0 ;
46311 PyObject *arg2 = (PyObject *) 0 ;
46312 int arg3 = (int) 0 ;
46313 int arg4 = (int) 0 ;
46314 int arg5 = (int) 0 ;
46315 PyObject *arg6 = (PyObject *) NULL ;
46316 wxSizerItem *result = 0 ;
46317 void *argp1 = 0 ;
46318 int res1 = 0 ;
46319 int val3 ;
46320 int ecode3 = 0 ;
46321 int val4 ;
46322 int ecode4 = 0 ;
46323 int val5 ;
46324 int ecode5 = 0 ;
46325 PyObject * obj0 = 0 ;
46326 PyObject * obj1 = 0 ;
46327 PyObject * obj2 = 0 ;
46328 PyObject * obj3 = 0 ;
46329 PyObject * obj4 = 0 ;
46330 PyObject * obj5 = 0 ;
46331 char * kwnames[] = {
46332 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46333 };
46334
46335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46337 if (!SWIG_IsOK(res1)) {
46338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46339 }
46340 arg1 = reinterpret_cast< wxSizer * >(argp1);
46341 arg2 = obj1;
46342 if (obj2) {
46343 ecode3 = SWIG_AsVal_int(obj2, &val3);
46344 if (!SWIG_IsOK(ecode3)) {
46345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46346 }
46347 arg3 = static_cast< int >(val3);
46348 }
46349 if (obj3) {
46350 ecode4 = SWIG_AsVal_int(obj3, &val4);
46351 if (!SWIG_IsOK(ecode4)) {
46352 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46353 }
46354 arg4 = static_cast< int >(val4);
46355 }
46356 if (obj4) {
46357 ecode5 = SWIG_AsVal_int(obj4, &val5);
46358 if (!SWIG_IsOK(ecode5)) {
46359 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46360 }
46361 arg5 = static_cast< int >(val5);
46362 }
46363 if (obj5) {
46364 arg6 = obj5;
46365 }
46366 {
46367 PyThreadState* __tstate = wxPyBeginAllowThreads();
46368 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46369 wxPyEndAllowThreads(__tstate);
46370 if (PyErr_Occurred()) SWIG_fail;
46371 }
46372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46373 return resultobj;
46374 fail:
46375 return NULL;
46376 }
46377
46378
46379 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46380 PyObject *resultobj = 0;
46381 wxSizer *arg1 = (wxSizer *) 0 ;
46382 int arg2 ;
46383 PyObject *arg3 = (PyObject *) 0 ;
46384 int arg4 = (int) 0 ;
46385 int arg5 = (int) 0 ;
46386 int arg6 = (int) 0 ;
46387 PyObject *arg7 = (PyObject *) NULL ;
46388 wxSizerItem *result = 0 ;
46389 void *argp1 = 0 ;
46390 int res1 = 0 ;
46391 int val2 ;
46392 int ecode2 = 0 ;
46393 int val4 ;
46394 int ecode4 = 0 ;
46395 int val5 ;
46396 int ecode5 = 0 ;
46397 int val6 ;
46398 int ecode6 = 0 ;
46399 PyObject * obj0 = 0 ;
46400 PyObject * obj1 = 0 ;
46401 PyObject * obj2 = 0 ;
46402 PyObject * obj3 = 0 ;
46403 PyObject * obj4 = 0 ;
46404 PyObject * obj5 = 0 ;
46405 PyObject * obj6 = 0 ;
46406 char * kwnames[] = {
46407 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46408 };
46409
46410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46412 if (!SWIG_IsOK(res1)) {
46413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46414 }
46415 arg1 = reinterpret_cast< wxSizer * >(argp1);
46416 ecode2 = SWIG_AsVal_int(obj1, &val2);
46417 if (!SWIG_IsOK(ecode2)) {
46418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46419 }
46420 arg2 = static_cast< int >(val2);
46421 arg3 = obj2;
46422 if (obj3) {
46423 ecode4 = SWIG_AsVal_int(obj3, &val4);
46424 if (!SWIG_IsOK(ecode4)) {
46425 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46426 }
46427 arg4 = static_cast< int >(val4);
46428 }
46429 if (obj4) {
46430 ecode5 = SWIG_AsVal_int(obj4, &val5);
46431 if (!SWIG_IsOK(ecode5)) {
46432 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46433 }
46434 arg5 = static_cast< int >(val5);
46435 }
46436 if (obj5) {
46437 ecode6 = SWIG_AsVal_int(obj5, &val6);
46438 if (!SWIG_IsOK(ecode6)) {
46439 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46440 }
46441 arg6 = static_cast< int >(val6);
46442 }
46443 if (obj6) {
46444 arg7 = obj6;
46445 }
46446 {
46447 PyThreadState* __tstate = wxPyBeginAllowThreads();
46448 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46449 wxPyEndAllowThreads(__tstate);
46450 if (PyErr_Occurred()) SWIG_fail;
46451 }
46452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46453 return resultobj;
46454 fail:
46455 return NULL;
46456 }
46457
46458
46459 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46460 PyObject *resultobj = 0;
46461 wxSizer *arg1 = (wxSizer *) 0 ;
46462 PyObject *arg2 = (PyObject *) 0 ;
46463 int arg3 = (int) 0 ;
46464 int arg4 = (int) 0 ;
46465 int arg5 = (int) 0 ;
46466 PyObject *arg6 = (PyObject *) NULL ;
46467 wxSizerItem *result = 0 ;
46468 void *argp1 = 0 ;
46469 int res1 = 0 ;
46470 int val3 ;
46471 int ecode3 = 0 ;
46472 int val4 ;
46473 int ecode4 = 0 ;
46474 int val5 ;
46475 int ecode5 = 0 ;
46476 PyObject * obj0 = 0 ;
46477 PyObject * obj1 = 0 ;
46478 PyObject * obj2 = 0 ;
46479 PyObject * obj3 = 0 ;
46480 PyObject * obj4 = 0 ;
46481 PyObject * obj5 = 0 ;
46482 char * kwnames[] = {
46483 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46484 };
46485
46486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46488 if (!SWIG_IsOK(res1)) {
46489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46490 }
46491 arg1 = reinterpret_cast< wxSizer * >(argp1);
46492 arg2 = obj1;
46493 if (obj2) {
46494 ecode3 = SWIG_AsVal_int(obj2, &val3);
46495 if (!SWIG_IsOK(ecode3)) {
46496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46497 }
46498 arg3 = static_cast< int >(val3);
46499 }
46500 if (obj3) {
46501 ecode4 = SWIG_AsVal_int(obj3, &val4);
46502 if (!SWIG_IsOK(ecode4)) {
46503 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46504 }
46505 arg4 = static_cast< int >(val4);
46506 }
46507 if (obj4) {
46508 ecode5 = SWIG_AsVal_int(obj4, &val5);
46509 if (!SWIG_IsOK(ecode5)) {
46510 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46511 }
46512 arg5 = static_cast< int >(val5);
46513 }
46514 if (obj5) {
46515 arg6 = obj5;
46516 }
46517 {
46518 PyThreadState* __tstate = wxPyBeginAllowThreads();
46519 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46520 wxPyEndAllowThreads(__tstate);
46521 if (PyErr_Occurred()) SWIG_fail;
46522 }
46523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46524 return resultobj;
46525 fail:
46526 return NULL;
46527 }
46528
46529
46530 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46531 PyObject *resultobj = 0;
46532 wxSizer *arg1 = (wxSizer *) 0 ;
46533 PyObject *arg2 = (PyObject *) 0 ;
46534 bool result;
46535 void *argp1 = 0 ;
46536 int res1 = 0 ;
46537 PyObject * obj0 = 0 ;
46538 PyObject * obj1 = 0 ;
46539 char * kwnames[] = {
46540 (char *) "self",(char *) "item", NULL
46541 };
46542
46543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46545 if (!SWIG_IsOK(res1)) {
46546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46547 }
46548 arg1 = reinterpret_cast< wxSizer * >(argp1);
46549 arg2 = obj1;
46550 {
46551 PyThreadState* __tstate = wxPyBeginAllowThreads();
46552 result = (bool)wxSizer_Remove(arg1,arg2);
46553 wxPyEndAllowThreads(__tstate);
46554 if (PyErr_Occurred()) SWIG_fail;
46555 }
46556 {
46557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46558 }
46559 return resultobj;
46560 fail:
46561 return NULL;
46562 }
46563
46564
46565 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46566 PyObject *resultobj = 0;
46567 wxSizer *arg1 = (wxSizer *) 0 ;
46568 PyObject *arg2 = (PyObject *) 0 ;
46569 bool result;
46570 void *argp1 = 0 ;
46571 int res1 = 0 ;
46572 PyObject * obj0 = 0 ;
46573 PyObject * obj1 = 0 ;
46574 char * kwnames[] = {
46575 (char *) "self",(char *) "item", NULL
46576 };
46577
46578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46580 if (!SWIG_IsOK(res1)) {
46581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46582 }
46583 arg1 = reinterpret_cast< wxSizer * >(argp1);
46584 arg2 = obj1;
46585 {
46586 PyThreadState* __tstate = wxPyBeginAllowThreads();
46587 result = (bool)wxSizer_Detach(arg1,arg2);
46588 wxPyEndAllowThreads(__tstate);
46589 if (PyErr_Occurred()) SWIG_fail;
46590 }
46591 {
46592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46593 }
46594 return resultobj;
46595 fail:
46596 return NULL;
46597 }
46598
46599
46600 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46601 PyObject *resultobj = 0;
46602 wxSizer *arg1 = (wxSizer *) 0 ;
46603 PyObject *arg2 = (PyObject *) 0 ;
46604 wxSizerItem *result = 0 ;
46605 void *argp1 = 0 ;
46606 int res1 = 0 ;
46607 PyObject * obj0 = 0 ;
46608 PyObject * obj1 = 0 ;
46609 char * kwnames[] = {
46610 (char *) "self",(char *) "item", NULL
46611 };
46612
46613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46615 if (!SWIG_IsOK(res1)) {
46616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46617 }
46618 arg1 = reinterpret_cast< wxSizer * >(argp1);
46619 arg2 = obj1;
46620 {
46621 PyThreadState* __tstate = wxPyBeginAllowThreads();
46622 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46623 wxPyEndAllowThreads(__tstate);
46624 if (PyErr_Occurred()) SWIG_fail;
46625 }
46626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46627 return resultobj;
46628 fail:
46629 return NULL;
46630 }
46631
46632
46633 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46634 PyObject *resultobj = 0;
46635 wxSizer *arg1 = (wxSizer *) 0 ;
46636 PyObject *arg2 = (PyObject *) 0 ;
46637 wxSize *arg3 = 0 ;
46638 void *argp1 = 0 ;
46639 int res1 = 0 ;
46640 wxSize temp3 ;
46641 PyObject * obj0 = 0 ;
46642 PyObject * obj1 = 0 ;
46643 PyObject * obj2 = 0 ;
46644 char * kwnames[] = {
46645 (char *) "self",(char *) "item",(char *) "size", NULL
46646 };
46647
46648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46650 if (!SWIG_IsOK(res1)) {
46651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46652 }
46653 arg1 = reinterpret_cast< wxSizer * >(argp1);
46654 arg2 = obj1;
46655 {
46656 arg3 = &temp3;
46657 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46658 }
46659 {
46660 PyThreadState* __tstate = wxPyBeginAllowThreads();
46661 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46662 wxPyEndAllowThreads(__tstate);
46663 if (PyErr_Occurred()) SWIG_fail;
46664 }
46665 resultobj = SWIG_Py_Void();
46666 return resultobj;
46667 fail:
46668 return NULL;
46669 }
46670
46671
46672 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46673 PyObject *resultobj = 0;
46674 wxSizer *arg1 = (wxSizer *) 0 ;
46675 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46676 wxSizerItem *result = 0 ;
46677 void *argp1 = 0 ;
46678 int res1 = 0 ;
46679 int res2 = 0 ;
46680 PyObject * obj0 = 0 ;
46681 PyObject * obj1 = 0 ;
46682 char * kwnames[] = {
46683 (char *) "self",(char *) "item", NULL
46684 };
46685
46686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46688 if (!SWIG_IsOK(res1)) {
46689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46690 }
46691 arg1 = reinterpret_cast< wxSizer * >(argp1);
46692 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46693 if (!SWIG_IsOK(res2)) {
46694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46695 }
46696 {
46697 PyThreadState* __tstate = wxPyBeginAllowThreads();
46698 result = (wxSizerItem *)(arg1)->Add(arg2);
46699 wxPyEndAllowThreads(__tstate);
46700 if (PyErr_Occurred()) SWIG_fail;
46701 }
46702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46703 return resultobj;
46704 fail:
46705 return NULL;
46706 }
46707
46708
46709 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46710 PyObject *resultobj = 0;
46711 wxSizer *arg1 = (wxSizer *) 0 ;
46712 size_t arg2 ;
46713 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46714 wxSizerItem *result = 0 ;
46715 void *argp1 = 0 ;
46716 int res1 = 0 ;
46717 size_t val2 ;
46718 int ecode2 = 0 ;
46719 int res3 = 0 ;
46720 PyObject * obj0 = 0 ;
46721 PyObject * obj1 = 0 ;
46722 PyObject * obj2 = 0 ;
46723 char * kwnames[] = {
46724 (char *) "self",(char *) "index",(char *) "item", NULL
46725 };
46726
46727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46729 if (!SWIG_IsOK(res1)) {
46730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46731 }
46732 arg1 = reinterpret_cast< wxSizer * >(argp1);
46733 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46734 if (!SWIG_IsOK(ecode2)) {
46735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46736 }
46737 arg2 = static_cast< size_t >(val2);
46738 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46739 if (!SWIG_IsOK(res3)) {
46740 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46741 }
46742 {
46743 PyThreadState* __tstate = wxPyBeginAllowThreads();
46744 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46745 wxPyEndAllowThreads(__tstate);
46746 if (PyErr_Occurred()) SWIG_fail;
46747 }
46748 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46749 return resultobj;
46750 fail:
46751 return NULL;
46752 }
46753
46754
46755 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46756 PyObject *resultobj = 0;
46757 wxSizer *arg1 = (wxSizer *) 0 ;
46758 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46759 wxSizerItem *result = 0 ;
46760 void *argp1 = 0 ;
46761 int res1 = 0 ;
46762 int res2 = 0 ;
46763 PyObject * obj0 = 0 ;
46764 PyObject * obj1 = 0 ;
46765 char * kwnames[] = {
46766 (char *) "self",(char *) "item", NULL
46767 };
46768
46769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46771 if (!SWIG_IsOK(res1)) {
46772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46773 }
46774 arg1 = reinterpret_cast< wxSizer * >(argp1);
46775 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46776 if (!SWIG_IsOK(res2)) {
46777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46778 }
46779 {
46780 PyThreadState* __tstate = wxPyBeginAllowThreads();
46781 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46782 wxPyEndAllowThreads(__tstate);
46783 if (PyErr_Occurred()) SWIG_fail;
46784 }
46785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46786 return resultobj;
46787 fail:
46788 return NULL;
46789 }
46790
46791
46792 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46793 PyObject *resultobj = 0;
46794 wxSizer *arg1 = (wxSizer *) 0 ;
46795 int arg2 ;
46796 int arg3 ;
46797 int arg4 ;
46798 int arg5 ;
46799 void *argp1 = 0 ;
46800 int res1 = 0 ;
46801 int val2 ;
46802 int ecode2 = 0 ;
46803 int val3 ;
46804 int ecode3 = 0 ;
46805 int val4 ;
46806 int ecode4 = 0 ;
46807 int val5 ;
46808 int ecode5 = 0 ;
46809 PyObject * obj0 = 0 ;
46810 PyObject * obj1 = 0 ;
46811 PyObject * obj2 = 0 ;
46812 PyObject * obj3 = 0 ;
46813 PyObject * obj4 = 0 ;
46814 char * kwnames[] = {
46815 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46816 };
46817
46818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46820 if (!SWIG_IsOK(res1)) {
46821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46822 }
46823 arg1 = reinterpret_cast< wxSizer * >(argp1);
46824 ecode2 = SWIG_AsVal_int(obj1, &val2);
46825 if (!SWIG_IsOK(ecode2)) {
46826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46827 }
46828 arg2 = static_cast< int >(val2);
46829 ecode3 = SWIG_AsVal_int(obj2, &val3);
46830 if (!SWIG_IsOK(ecode3)) {
46831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46832 }
46833 arg3 = static_cast< int >(val3);
46834 ecode4 = SWIG_AsVal_int(obj3, &val4);
46835 if (!SWIG_IsOK(ecode4)) {
46836 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46837 }
46838 arg4 = static_cast< int >(val4);
46839 ecode5 = SWIG_AsVal_int(obj4, &val5);
46840 if (!SWIG_IsOK(ecode5)) {
46841 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46842 }
46843 arg5 = static_cast< int >(val5);
46844 {
46845 PyThreadState* __tstate = wxPyBeginAllowThreads();
46846 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46847 wxPyEndAllowThreads(__tstate);
46848 if (PyErr_Occurred()) SWIG_fail;
46849 }
46850 resultobj = SWIG_Py_Void();
46851 return resultobj;
46852 fail:
46853 return NULL;
46854 }
46855
46856
46857 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46858 PyObject *resultobj = 0;
46859 wxSizer *arg1 = (wxSizer *) 0 ;
46860 wxSize *arg2 = 0 ;
46861 void *argp1 = 0 ;
46862 int res1 = 0 ;
46863 wxSize temp2 ;
46864 PyObject * obj0 = 0 ;
46865 PyObject * obj1 = 0 ;
46866 char * kwnames[] = {
46867 (char *) "self",(char *) "size", NULL
46868 };
46869
46870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46872 if (!SWIG_IsOK(res1)) {
46873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46874 }
46875 arg1 = reinterpret_cast< wxSizer * >(argp1);
46876 {
46877 arg2 = &temp2;
46878 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46879 }
46880 {
46881 PyThreadState* __tstate = wxPyBeginAllowThreads();
46882 (arg1)->SetMinSize((wxSize const &)*arg2);
46883 wxPyEndAllowThreads(__tstate);
46884 if (PyErr_Occurred()) SWIG_fail;
46885 }
46886 resultobj = SWIG_Py_Void();
46887 return resultobj;
46888 fail:
46889 return NULL;
46890 }
46891
46892
46893 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46894 PyObject *resultobj = 0;
46895 wxSizer *arg1 = (wxSizer *) 0 ;
46896 wxSize result;
46897 void *argp1 = 0 ;
46898 int res1 = 0 ;
46899 PyObject *swig_obj[1] ;
46900
46901 if (!args) SWIG_fail;
46902 swig_obj[0] = args;
46903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46904 if (!SWIG_IsOK(res1)) {
46905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46906 }
46907 arg1 = reinterpret_cast< wxSizer * >(argp1);
46908 {
46909 PyThreadState* __tstate = wxPyBeginAllowThreads();
46910 result = (arg1)->GetSize();
46911 wxPyEndAllowThreads(__tstate);
46912 if (PyErr_Occurred()) SWIG_fail;
46913 }
46914 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46915 return resultobj;
46916 fail:
46917 return NULL;
46918 }
46919
46920
46921 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46922 PyObject *resultobj = 0;
46923 wxSizer *arg1 = (wxSizer *) 0 ;
46924 wxPoint result;
46925 void *argp1 = 0 ;
46926 int res1 = 0 ;
46927 PyObject *swig_obj[1] ;
46928
46929 if (!args) SWIG_fail;
46930 swig_obj[0] = args;
46931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46932 if (!SWIG_IsOK(res1)) {
46933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46934 }
46935 arg1 = reinterpret_cast< wxSizer * >(argp1);
46936 {
46937 PyThreadState* __tstate = wxPyBeginAllowThreads();
46938 result = (arg1)->GetPosition();
46939 wxPyEndAllowThreads(__tstate);
46940 if (PyErr_Occurred()) SWIG_fail;
46941 }
46942 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46943 return resultobj;
46944 fail:
46945 return NULL;
46946 }
46947
46948
46949 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46950 PyObject *resultobj = 0;
46951 wxSizer *arg1 = (wxSizer *) 0 ;
46952 wxSize result;
46953 void *argp1 = 0 ;
46954 int res1 = 0 ;
46955 PyObject *swig_obj[1] ;
46956
46957 if (!args) SWIG_fail;
46958 swig_obj[0] = args;
46959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46960 if (!SWIG_IsOK(res1)) {
46961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46962 }
46963 arg1 = reinterpret_cast< wxSizer * >(argp1);
46964 {
46965 PyThreadState* __tstate = wxPyBeginAllowThreads();
46966 result = (arg1)->GetMinSize();
46967 wxPyEndAllowThreads(__tstate);
46968 if (PyErr_Occurred()) SWIG_fail;
46969 }
46970 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46971 return resultobj;
46972 fail:
46973 return NULL;
46974 }
46975
46976
46977 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46978 PyObject *resultobj = 0;
46979 wxSizer *arg1 = (wxSizer *) 0 ;
46980 void *argp1 = 0 ;
46981 int res1 = 0 ;
46982 PyObject *swig_obj[1] ;
46983
46984 if (!args) SWIG_fail;
46985 swig_obj[0] = args;
46986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46987 if (!SWIG_IsOK(res1)) {
46988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46989 }
46990 arg1 = reinterpret_cast< wxSizer * >(argp1);
46991 {
46992 PyThreadState* __tstate = wxPyBeginAllowThreads();
46993 (arg1)->RecalcSizes();
46994 wxPyEndAllowThreads(__tstate);
46995 if (PyErr_Occurred()) SWIG_fail;
46996 }
46997 resultobj = SWIG_Py_Void();
46998 return resultobj;
46999 fail:
47000 return NULL;
47001 }
47002
47003
47004 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47005 PyObject *resultobj = 0;
47006 wxSizer *arg1 = (wxSizer *) 0 ;
47007 wxSize result;
47008 void *argp1 = 0 ;
47009 int res1 = 0 ;
47010 PyObject *swig_obj[1] ;
47011
47012 if (!args) SWIG_fail;
47013 swig_obj[0] = args;
47014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47015 if (!SWIG_IsOK(res1)) {
47016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47017 }
47018 arg1 = reinterpret_cast< wxSizer * >(argp1);
47019 {
47020 PyThreadState* __tstate = wxPyBeginAllowThreads();
47021 result = (arg1)->CalcMin();
47022 wxPyEndAllowThreads(__tstate);
47023 if (PyErr_Occurred()) SWIG_fail;
47024 }
47025 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47026 return resultobj;
47027 fail:
47028 return NULL;
47029 }
47030
47031
47032 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47033 PyObject *resultobj = 0;
47034 wxSizer *arg1 = (wxSizer *) 0 ;
47035 void *argp1 = 0 ;
47036 int res1 = 0 ;
47037 PyObject *swig_obj[1] ;
47038
47039 if (!args) SWIG_fail;
47040 swig_obj[0] = args;
47041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47042 if (!SWIG_IsOK(res1)) {
47043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47044 }
47045 arg1 = reinterpret_cast< wxSizer * >(argp1);
47046 {
47047 PyThreadState* __tstate = wxPyBeginAllowThreads();
47048 (arg1)->Layout();
47049 wxPyEndAllowThreads(__tstate);
47050 if (PyErr_Occurred()) SWIG_fail;
47051 }
47052 resultobj = SWIG_Py_Void();
47053 return resultobj;
47054 fail:
47055 return NULL;
47056 }
47057
47058
47059 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47060 PyObject *resultobj = 0;
47061 wxSizer *arg1 = (wxSizer *) 0 ;
47062 wxWindow *arg2 = (wxWindow *) 0 ;
47063 wxSize result;
47064 void *argp1 = 0 ;
47065 int res1 = 0 ;
47066 void *argp2 = 0 ;
47067 int res2 = 0 ;
47068 PyObject * obj0 = 0 ;
47069 PyObject * obj1 = 0 ;
47070 char * kwnames[] = {
47071 (char *) "self",(char *) "window", NULL
47072 };
47073
47074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47076 if (!SWIG_IsOK(res1)) {
47077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47078 }
47079 arg1 = reinterpret_cast< wxSizer * >(argp1);
47080 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47081 if (!SWIG_IsOK(res2)) {
47082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47083 }
47084 arg2 = reinterpret_cast< wxWindow * >(argp2);
47085 {
47086 PyThreadState* __tstate = wxPyBeginAllowThreads();
47087 result = (arg1)->Fit(arg2);
47088 wxPyEndAllowThreads(__tstate);
47089 if (PyErr_Occurred()) SWIG_fail;
47090 }
47091 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47092 return resultobj;
47093 fail:
47094 return NULL;
47095 }
47096
47097
47098 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47099 PyObject *resultobj = 0;
47100 wxSizer *arg1 = (wxSizer *) 0 ;
47101 wxWindow *arg2 = (wxWindow *) 0 ;
47102 void *argp1 = 0 ;
47103 int res1 = 0 ;
47104 void *argp2 = 0 ;
47105 int res2 = 0 ;
47106 PyObject * obj0 = 0 ;
47107 PyObject * obj1 = 0 ;
47108 char * kwnames[] = {
47109 (char *) "self",(char *) "window", NULL
47110 };
47111
47112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47114 if (!SWIG_IsOK(res1)) {
47115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47116 }
47117 arg1 = reinterpret_cast< wxSizer * >(argp1);
47118 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47119 if (!SWIG_IsOK(res2)) {
47120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47121 }
47122 arg2 = reinterpret_cast< wxWindow * >(argp2);
47123 {
47124 PyThreadState* __tstate = wxPyBeginAllowThreads();
47125 (arg1)->FitInside(arg2);
47126 wxPyEndAllowThreads(__tstate);
47127 if (PyErr_Occurred()) SWIG_fail;
47128 }
47129 resultobj = SWIG_Py_Void();
47130 return resultobj;
47131 fail:
47132 return NULL;
47133 }
47134
47135
47136 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47137 PyObject *resultobj = 0;
47138 wxSizer *arg1 = (wxSizer *) 0 ;
47139 wxWindow *arg2 = (wxWindow *) 0 ;
47140 void *argp1 = 0 ;
47141 int res1 = 0 ;
47142 void *argp2 = 0 ;
47143 int res2 = 0 ;
47144 PyObject * obj0 = 0 ;
47145 PyObject * obj1 = 0 ;
47146 char * kwnames[] = {
47147 (char *) "self",(char *) "window", NULL
47148 };
47149
47150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47152 if (!SWIG_IsOK(res1)) {
47153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47154 }
47155 arg1 = reinterpret_cast< wxSizer * >(argp1);
47156 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47157 if (!SWIG_IsOK(res2)) {
47158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47159 }
47160 arg2 = reinterpret_cast< wxWindow * >(argp2);
47161 {
47162 PyThreadState* __tstate = wxPyBeginAllowThreads();
47163 (arg1)->SetSizeHints(arg2);
47164 wxPyEndAllowThreads(__tstate);
47165 if (PyErr_Occurred()) SWIG_fail;
47166 }
47167 resultobj = SWIG_Py_Void();
47168 return resultobj;
47169 fail:
47170 return NULL;
47171 }
47172
47173
47174 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47175 PyObject *resultobj = 0;
47176 wxSizer *arg1 = (wxSizer *) 0 ;
47177 wxWindow *arg2 = (wxWindow *) 0 ;
47178 void *argp1 = 0 ;
47179 int res1 = 0 ;
47180 void *argp2 = 0 ;
47181 int res2 = 0 ;
47182 PyObject * obj0 = 0 ;
47183 PyObject * obj1 = 0 ;
47184 char * kwnames[] = {
47185 (char *) "self",(char *) "window", NULL
47186 };
47187
47188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47190 if (!SWIG_IsOK(res1)) {
47191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47192 }
47193 arg1 = reinterpret_cast< wxSizer * >(argp1);
47194 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47195 if (!SWIG_IsOK(res2)) {
47196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47197 }
47198 arg2 = reinterpret_cast< wxWindow * >(argp2);
47199 {
47200 PyThreadState* __tstate = wxPyBeginAllowThreads();
47201 (arg1)->SetVirtualSizeHints(arg2);
47202 wxPyEndAllowThreads(__tstate);
47203 if (PyErr_Occurred()) SWIG_fail;
47204 }
47205 resultobj = SWIG_Py_Void();
47206 return resultobj;
47207 fail:
47208 return NULL;
47209 }
47210
47211
47212 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47213 PyObject *resultobj = 0;
47214 wxSizer *arg1 = (wxSizer *) 0 ;
47215 bool arg2 = (bool) false ;
47216 void *argp1 = 0 ;
47217 int res1 = 0 ;
47218 bool val2 ;
47219 int ecode2 = 0 ;
47220 PyObject * obj0 = 0 ;
47221 PyObject * obj1 = 0 ;
47222 char * kwnames[] = {
47223 (char *) "self",(char *) "deleteWindows", NULL
47224 };
47225
47226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47228 if (!SWIG_IsOK(res1)) {
47229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47230 }
47231 arg1 = reinterpret_cast< wxSizer * >(argp1);
47232 if (obj1) {
47233 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47234 if (!SWIG_IsOK(ecode2)) {
47235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47236 }
47237 arg2 = static_cast< bool >(val2);
47238 }
47239 {
47240 PyThreadState* __tstate = wxPyBeginAllowThreads();
47241 (arg1)->Clear(arg2);
47242 wxPyEndAllowThreads(__tstate);
47243 if (PyErr_Occurred()) SWIG_fail;
47244 }
47245 resultobj = SWIG_Py_Void();
47246 return resultobj;
47247 fail:
47248 return NULL;
47249 }
47250
47251
47252 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47253 PyObject *resultobj = 0;
47254 wxSizer *arg1 = (wxSizer *) 0 ;
47255 void *argp1 = 0 ;
47256 int res1 = 0 ;
47257 PyObject *swig_obj[1] ;
47258
47259 if (!args) SWIG_fail;
47260 swig_obj[0] = args;
47261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47262 if (!SWIG_IsOK(res1)) {
47263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47264 }
47265 arg1 = reinterpret_cast< wxSizer * >(argp1);
47266 {
47267 PyThreadState* __tstate = wxPyBeginAllowThreads();
47268 (arg1)->DeleteWindows();
47269 wxPyEndAllowThreads(__tstate);
47270 if (PyErr_Occurred()) SWIG_fail;
47271 }
47272 resultobj = SWIG_Py_Void();
47273 return resultobj;
47274 fail:
47275 return NULL;
47276 }
47277
47278
47279 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47280 PyObject *resultobj = 0;
47281 wxSizer *arg1 = (wxSizer *) 0 ;
47282 PyObject *result = 0 ;
47283 void *argp1 = 0 ;
47284 int res1 = 0 ;
47285 PyObject *swig_obj[1] ;
47286
47287 if (!args) SWIG_fail;
47288 swig_obj[0] = args;
47289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47290 if (!SWIG_IsOK(res1)) {
47291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47292 }
47293 arg1 = reinterpret_cast< wxSizer * >(argp1);
47294 {
47295 PyThreadState* __tstate = wxPyBeginAllowThreads();
47296 result = (PyObject *)wxSizer_GetChildren(arg1);
47297 wxPyEndAllowThreads(__tstate);
47298 if (PyErr_Occurred()) SWIG_fail;
47299 }
47300 resultobj = result;
47301 return resultobj;
47302 fail:
47303 return NULL;
47304 }
47305
47306
47307 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47308 PyObject *resultobj = 0;
47309 wxSizer *arg1 = (wxSizer *) 0 ;
47310 PyObject *arg2 = (PyObject *) 0 ;
47311 bool arg3 = (bool) true ;
47312 bool arg4 = (bool) false ;
47313 bool result;
47314 void *argp1 = 0 ;
47315 int res1 = 0 ;
47316 bool val3 ;
47317 int ecode3 = 0 ;
47318 bool val4 ;
47319 int ecode4 = 0 ;
47320 PyObject * obj0 = 0 ;
47321 PyObject * obj1 = 0 ;
47322 PyObject * obj2 = 0 ;
47323 PyObject * obj3 = 0 ;
47324 char * kwnames[] = {
47325 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47326 };
47327
47328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47330 if (!SWIG_IsOK(res1)) {
47331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47332 }
47333 arg1 = reinterpret_cast< wxSizer * >(argp1);
47334 arg2 = obj1;
47335 if (obj2) {
47336 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47337 if (!SWIG_IsOK(ecode3)) {
47338 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47339 }
47340 arg3 = static_cast< bool >(val3);
47341 }
47342 if (obj3) {
47343 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47344 if (!SWIG_IsOK(ecode4)) {
47345 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47346 }
47347 arg4 = static_cast< bool >(val4);
47348 }
47349 {
47350 PyThreadState* __tstate = wxPyBeginAllowThreads();
47351 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47352 wxPyEndAllowThreads(__tstate);
47353 if (PyErr_Occurred()) SWIG_fail;
47354 }
47355 {
47356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47357 }
47358 return resultobj;
47359 fail:
47360 return NULL;
47361 }
47362
47363
47364 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47365 PyObject *resultobj = 0;
47366 wxSizer *arg1 = (wxSizer *) 0 ;
47367 PyObject *arg2 = (PyObject *) 0 ;
47368 bool result;
47369 void *argp1 = 0 ;
47370 int res1 = 0 ;
47371 PyObject * obj0 = 0 ;
47372 PyObject * obj1 = 0 ;
47373 char * kwnames[] = {
47374 (char *) "self",(char *) "item", NULL
47375 };
47376
47377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47379 if (!SWIG_IsOK(res1)) {
47380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47381 }
47382 arg1 = reinterpret_cast< wxSizer * >(argp1);
47383 arg2 = obj1;
47384 {
47385 PyThreadState* __tstate = wxPyBeginAllowThreads();
47386 result = (bool)wxSizer_IsShown(arg1,arg2);
47387 wxPyEndAllowThreads(__tstate);
47388 if (PyErr_Occurred()) SWIG_fail;
47389 }
47390 {
47391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47392 }
47393 return resultobj;
47394 fail:
47395 return NULL;
47396 }
47397
47398
47399 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47400 PyObject *resultobj = 0;
47401 wxSizer *arg1 = (wxSizer *) 0 ;
47402 bool arg2 ;
47403 void *argp1 = 0 ;
47404 int res1 = 0 ;
47405 bool val2 ;
47406 int ecode2 = 0 ;
47407 PyObject * obj0 = 0 ;
47408 PyObject * obj1 = 0 ;
47409 char * kwnames[] = {
47410 (char *) "self",(char *) "show", NULL
47411 };
47412
47413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47415 if (!SWIG_IsOK(res1)) {
47416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47417 }
47418 arg1 = reinterpret_cast< wxSizer * >(argp1);
47419 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47420 if (!SWIG_IsOK(ecode2)) {
47421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47422 }
47423 arg2 = static_cast< bool >(val2);
47424 {
47425 PyThreadState* __tstate = wxPyBeginAllowThreads();
47426 (arg1)->ShowItems(arg2);
47427 wxPyEndAllowThreads(__tstate);
47428 if (PyErr_Occurred()) SWIG_fail;
47429 }
47430 resultobj = SWIG_Py_Void();
47431 return resultobj;
47432 fail:
47433 return NULL;
47434 }
47435
47436
47437 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47438 PyObject *obj;
47439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47440 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47441 return SWIG_Py_Void();
47442 }
47443
47444 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47445 PyObject *resultobj = 0;
47446 wxPySizer *result = 0 ;
47447
47448 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47449 {
47450 PyThreadState* __tstate = wxPyBeginAllowThreads();
47451 result = (wxPySizer *)new wxPySizer();
47452 wxPyEndAllowThreads(__tstate);
47453 if (PyErr_Occurred()) SWIG_fail;
47454 }
47455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47456 return resultobj;
47457 fail:
47458 return NULL;
47459 }
47460
47461
47462 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47463 PyObject *resultobj = 0;
47464 wxPySizer *arg1 = (wxPySizer *) 0 ;
47465 PyObject *arg2 = (PyObject *) 0 ;
47466 PyObject *arg3 = (PyObject *) 0 ;
47467 void *argp1 = 0 ;
47468 int res1 = 0 ;
47469 PyObject * obj0 = 0 ;
47470 PyObject * obj1 = 0 ;
47471 PyObject * obj2 = 0 ;
47472 char * kwnames[] = {
47473 (char *) "self",(char *) "self",(char *) "_class", NULL
47474 };
47475
47476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47478 if (!SWIG_IsOK(res1)) {
47479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47480 }
47481 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47482 arg2 = obj1;
47483 arg3 = obj2;
47484 {
47485 PyThreadState* __tstate = wxPyBeginAllowThreads();
47486 (arg1)->_setCallbackInfo(arg2,arg3);
47487 wxPyEndAllowThreads(__tstate);
47488 if (PyErr_Occurred()) SWIG_fail;
47489 }
47490 resultobj = SWIG_Py_Void();
47491 return resultobj;
47492 fail:
47493 return NULL;
47494 }
47495
47496
47497 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47498 PyObject *obj;
47499 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47500 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47501 return SWIG_Py_Void();
47502 }
47503
47504 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47505 return SWIG_Python_InitShadowInstance(args);
47506 }
47507
47508 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47509 PyObject *resultobj = 0;
47510 int arg1 = (int) wxHORIZONTAL ;
47511 wxBoxSizer *result = 0 ;
47512 int val1 ;
47513 int ecode1 = 0 ;
47514 PyObject * obj0 = 0 ;
47515 char * kwnames[] = {
47516 (char *) "orient", NULL
47517 };
47518
47519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47520 if (obj0) {
47521 ecode1 = SWIG_AsVal_int(obj0, &val1);
47522 if (!SWIG_IsOK(ecode1)) {
47523 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47524 }
47525 arg1 = static_cast< int >(val1);
47526 }
47527 {
47528 PyThreadState* __tstate = wxPyBeginAllowThreads();
47529 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47530 wxPyEndAllowThreads(__tstate);
47531 if (PyErr_Occurred()) SWIG_fail;
47532 }
47533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47534 return resultobj;
47535 fail:
47536 return NULL;
47537 }
47538
47539
47540 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47541 PyObject *resultobj = 0;
47542 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47543 int result;
47544 void *argp1 = 0 ;
47545 int res1 = 0 ;
47546 PyObject *swig_obj[1] ;
47547
47548 if (!args) SWIG_fail;
47549 swig_obj[0] = args;
47550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47551 if (!SWIG_IsOK(res1)) {
47552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47553 }
47554 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47555 {
47556 PyThreadState* __tstate = wxPyBeginAllowThreads();
47557 result = (int)(arg1)->GetOrientation();
47558 wxPyEndAllowThreads(__tstate);
47559 if (PyErr_Occurred()) SWIG_fail;
47560 }
47561 resultobj = SWIG_From_int(static_cast< int >(result));
47562 return resultobj;
47563 fail:
47564 return NULL;
47565 }
47566
47567
47568 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47569 PyObject *resultobj = 0;
47570 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47571 int arg2 ;
47572 void *argp1 = 0 ;
47573 int res1 = 0 ;
47574 int val2 ;
47575 int ecode2 = 0 ;
47576 PyObject * obj0 = 0 ;
47577 PyObject * obj1 = 0 ;
47578 char * kwnames[] = {
47579 (char *) "self",(char *) "orient", NULL
47580 };
47581
47582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47584 if (!SWIG_IsOK(res1)) {
47585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47586 }
47587 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47588 ecode2 = SWIG_AsVal_int(obj1, &val2);
47589 if (!SWIG_IsOK(ecode2)) {
47590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47591 }
47592 arg2 = static_cast< int >(val2);
47593 {
47594 PyThreadState* __tstate = wxPyBeginAllowThreads();
47595 (arg1)->SetOrientation(arg2);
47596 wxPyEndAllowThreads(__tstate);
47597 if (PyErr_Occurred()) SWIG_fail;
47598 }
47599 resultobj = SWIG_Py_Void();
47600 return resultobj;
47601 fail:
47602 return NULL;
47603 }
47604
47605
47606 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47607 PyObject *obj;
47608 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47609 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47610 return SWIG_Py_Void();
47611 }
47612
47613 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47614 return SWIG_Python_InitShadowInstance(args);
47615 }
47616
47617 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47618 PyObject *resultobj = 0;
47619 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47620 int arg2 = (int) wxHORIZONTAL ;
47621 wxStaticBoxSizer *result = 0 ;
47622 void *argp1 = 0 ;
47623 int res1 = 0 ;
47624 int val2 ;
47625 int ecode2 = 0 ;
47626 PyObject * obj0 = 0 ;
47627 PyObject * obj1 = 0 ;
47628 char * kwnames[] = {
47629 (char *) "box",(char *) "orient", NULL
47630 };
47631
47632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47634 if (!SWIG_IsOK(res1)) {
47635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47636 }
47637 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47638 if (obj1) {
47639 ecode2 = SWIG_AsVal_int(obj1, &val2);
47640 if (!SWIG_IsOK(ecode2)) {
47641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47642 }
47643 arg2 = static_cast< int >(val2);
47644 }
47645 {
47646 PyThreadState* __tstate = wxPyBeginAllowThreads();
47647 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47648 wxPyEndAllowThreads(__tstate);
47649 if (PyErr_Occurred()) SWIG_fail;
47650 }
47651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47652 return resultobj;
47653 fail:
47654 return NULL;
47655 }
47656
47657
47658 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47659 PyObject *resultobj = 0;
47660 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47661 wxStaticBox *result = 0 ;
47662 void *argp1 = 0 ;
47663 int res1 = 0 ;
47664 PyObject *swig_obj[1] ;
47665
47666 if (!args) SWIG_fail;
47667 swig_obj[0] = args;
47668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47669 if (!SWIG_IsOK(res1)) {
47670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47671 }
47672 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47673 {
47674 PyThreadState* __tstate = wxPyBeginAllowThreads();
47675 result = (wxStaticBox *)(arg1)->GetStaticBox();
47676 wxPyEndAllowThreads(__tstate);
47677 if (PyErr_Occurred()) SWIG_fail;
47678 }
47679 {
47680 resultobj = wxPyMake_wxObject(result, (bool)0);
47681 }
47682 return resultobj;
47683 fail:
47684 return NULL;
47685 }
47686
47687
47688 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47689 PyObject *obj;
47690 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47691 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47692 return SWIG_Py_Void();
47693 }
47694
47695 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47696 return SWIG_Python_InitShadowInstance(args);
47697 }
47698
47699 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47700 PyObject *resultobj = 0;
47701 int arg1 = (int) 1 ;
47702 int arg2 = (int) 0 ;
47703 int arg3 = (int) 0 ;
47704 int arg4 = (int) 0 ;
47705 wxGridSizer *result = 0 ;
47706 int val1 ;
47707 int ecode1 = 0 ;
47708 int val2 ;
47709 int ecode2 = 0 ;
47710 int val3 ;
47711 int ecode3 = 0 ;
47712 int val4 ;
47713 int ecode4 = 0 ;
47714 PyObject * obj0 = 0 ;
47715 PyObject * obj1 = 0 ;
47716 PyObject * obj2 = 0 ;
47717 PyObject * obj3 = 0 ;
47718 char * kwnames[] = {
47719 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47720 };
47721
47722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47723 if (obj0) {
47724 ecode1 = SWIG_AsVal_int(obj0, &val1);
47725 if (!SWIG_IsOK(ecode1)) {
47726 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47727 }
47728 arg1 = static_cast< int >(val1);
47729 }
47730 if (obj1) {
47731 ecode2 = SWIG_AsVal_int(obj1, &val2);
47732 if (!SWIG_IsOK(ecode2)) {
47733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47734 }
47735 arg2 = static_cast< int >(val2);
47736 }
47737 if (obj2) {
47738 ecode3 = SWIG_AsVal_int(obj2, &val3);
47739 if (!SWIG_IsOK(ecode3)) {
47740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47741 }
47742 arg3 = static_cast< int >(val3);
47743 }
47744 if (obj3) {
47745 ecode4 = SWIG_AsVal_int(obj3, &val4);
47746 if (!SWIG_IsOK(ecode4)) {
47747 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47748 }
47749 arg4 = static_cast< int >(val4);
47750 }
47751 {
47752 PyThreadState* __tstate = wxPyBeginAllowThreads();
47753 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47754 wxPyEndAllowThreads(__tstate);
47755 if (PyErr_Occurred()) SWIG_fail;
47756 }
47757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47758 return resultobj;
47759 fail:
47760 return NULL;
47761 }
47762
47763
47764 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47765 PyObject *resultobj = 0;
47766 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47767 int arg2 ;
47768 void *argp1 = 0 ;
47769 int res1 = 0 ;
47770 int val2 ;
47771 int ecode2 = 0 ;
47772 PyObject * obj0 = 0 ;
47773 PyObject * obj1 = 0 ;
47774 char * kwnames[] = {
47775 (char *) "self",(char *) "cols", NULL
47776 };
47777
47778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47780 if (!SWIG_IsOK(res1)) {
47781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47782 }
47783 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47784 ecode2 = SWIG_AsVal_int(obj1, &val2);
47785 if (!SWIG_IsOK(ecode2)) {
47786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47787 }
47788 arg2 = static_cast< int >(val2);
47789 {
47790 PyThreadState* __tstate = wxPyBeginAllowThreads();
47791 (arg1)->SetCols(arg2);
47792 wxPyEndAllowThreads(__tstate);
47793 if (PyErr_Occurred()) SWIG_fail;
47794 }
47795 resultobj = SWIG_Py_Void();
47796 return resultobj;
47797 fail:
47798 return NULL;
47799 }
47800
47801
47802 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47803 PyObject *resultobj = 0;
47804 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47805 int arg2 ;
47806 void *argp1 = 0 ;
47807 int res1 = 0 ;
47808 int val2 ;
47809 int ecode2 = 0 ;
47810 PyObject * obj0 = 0 ;
47811 PyObject * obj1 = 0 ;
47812 char * kwnames[] = {
47813 (char *) "self",(char *) "rows", NULL
47814 };
47815
47816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47818 if (!SWIG_IsOK(res1)) {
47819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47820 }
47821 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47822 ecode2 = SWIG_AsVal_int(obj1, &val2);
47823 if (!SWIG_IsOK(ecode2)) {
47824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47825 }
47826 arg2 = static_cast< int >(val2);
47827 {
47828 PyThreadState* __tstate = wxPyBeginAllowThreads();
47829 (arg1)->SetRows(arg2);
47830 wxPyEndAllowThreads(__tstate);
47831 if (PyErr_Occurred()) SWIG_fail;
47832 }
47833 resultobj = SWIG_Py_Void();
47834 return resultobj;
47835 fail:
47836 return NULL;
47837 }
47838
47839
47840 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47841 PyObject *resultobj = 0;
47842 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47843 int arg2 ;
47844 void *argp1 = 0 ;
47845 int res1 = 0 ;
47846 int val2 ;
47847 int ecode2 = 0 ;
47848 PyObject * obj0 = 0 ;
47849 PyObject * obj1 = 0 ;
47850 char * kwnames[] = {
47851 (char *) "self",(char *) "gap", NULL
47852 };
47853
47854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47856 if (!SWIG_IsOK(res1)) {
47857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47858 }
47859 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47860 ecode2 = SWIG_AsVal_int(obj1, &val2);
47861 if (!SWIG_IsOK(ecode2)) {
47862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47863 }
47864 arg2 = static_cast< int >(val2);
47865 {
47866 PyThreadState* __tstate = wxPyBeginAllowThreads();
47867 (arg1)->SetVGap(arg2);
47868 wxPyEndAllowThreads(__tstate);
47869 if (PyErr_Occurred()) SWIG_fail;
47870 }
47871 resultobj = SWIG_Py_Void();
47872 return resultobj;
47873 fail:
47874 return NULL;
47875 }
47876
47877
47878 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47879 PyObject *resultobj = 0;
47880 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47881 int arg2 ;
47882 void *argp1 = 0 ;
47883 int res1 = 0 ;
47884 int val2 ;
47885 int ecode2 = 0 ;
47886 PyObject * obj0 = 0 ;
47887 PyObject * obj1 = 0 ;
47888 char * kwnames[] = {
47889 (char *) "self",(char *) "gap", NULL
47890 };
47891
47892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47894 if (!SWIG_IsOK(res1)) {
47895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47896 }
47897 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47898 ecode2 = SWIG_AsVal_int(obj1, &val2);
47899 if (!SWIG_IsOK(ecode2)) {
47900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47901 }
47902 arg2 = static_cast< int >(val2);
47903 {
47904 PyThreadState* __tstate = wxPyBeginAllowThreads();
47905 (arg1)->SetHGap(arg2);
47906 wxPyEndAllowThreads(__tstate);
47907 if (PyErr_Occurred()) SWIG_fail;
47908 }
47909 resultobj = SWIG_Py_Void();
47910 return resultobj;
47911 fail:
47912 return NULL;
47913 }
47914
47915
47916 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47917 PyObject *resultobj = 0;
47918 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47919 int result;
47920 void *argp1 = 0 ;
47921 int res1 = 0 ;
47922 PyObject *swig_obj[1] ;
47923
47924 if (!args) SWIG_fail;
47925 swig_obj[0] = args;
47926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47927 if (!SWIG_IsOK(res1)) {
47928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47929 }
47930 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47931 {
47932 PyThreadState* __tstate = wxPyBeginAllowThreads();
47933 result = (int)(arg1)->GetCols();
47934 wxPyEndAllowThreads(__tstate);
47935 if (PyErr_Occurred()) SWIG_fail;
47936 }
47937 resultobj = SWIG_From_int(static_cast< int >(result));
47938 return resultobj;
47939 fail:
47940 return NULL;
47941 }
47942
47943
47944 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47945 PyObject *resultobj = 0;
47946 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47947 int result;
47948 void *argp1 = 0 ;
47949 int res1 = 0 ;
47950 PyObject *swig_obj[1] ;
47951
47952 if (!args) SWIG_fail;
47953 swig_obj[0] = args;
47954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47955 if (!SWIG_IsOK(res1)) {
47956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47957 }
47958 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47959 {
47960 PyThreadState* __tstate = wxPyBeginAllowThreads();
47961 result = (int)(arg1)->GetRows();
47962 wxPyEndAllowThreads(__tstate);
47963 if (PyErr_Occurred()) SWIG_fail;
47964 }
47965 resultobj = SWIG_From_int(static_cast< int >(result));
47966 return resultobj;
47967 fail:
47968 return NULL;
47969 }
47970
47971
47972 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47973 PyObject *resultobj = 0;
47974 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47975 int result;
47976 void *argp1 = 0 ;
47977 int res1 = 0 ;
47978 PyObject *swig_obj[1] ;
47979
47980 if (!args) SWIG_fail;
47981 swig_obj[0] = args;
47982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47983 if (!SWIG_IsOK(res1)) {
47984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47985 }
47986 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47987 {
47988 PyThreadState* __tstate = wxPyBeginAllowThreads();
47989 result = (int)(arg1)->GetVGap();
47990 wxPyEndAllowThreads(__tstate);
47991 if (PyErr_Occurred()) SWIG_fail;
47992 }
47993 resultobj = SWIG_From_int(static_cast< int >(result));
47994 return resultobj;
47995 fail:
47996 return NULL;
47997 }
47998
47999
48000 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48001 PyObject *resultobj = 0;
48002 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48003 int result;
48004 void *argp1 = 0 ;
48005 int res1 = 0 ;
48006 PyObject *swig_obj[1] ;
48007
48008 if (!args) SWIG_fail;
48009 swig_obj[0] = args;
48010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48011 if (!SWIG_IsOK(res1)) {
48012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48013 }
48014 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48015 {
48016 PyThreadState* __tstate = wxPyBeginAllowThreads();
48017 result = (int)(arg1)->GetHGap();
48018 wxPyEndAllowThreads(__tstate);
48019 if (PyErr_Occurred()) SWIG_fail;
48020 }
48021 resultobj = SWIG_From_int(static_cast< int >(result));
48022 return resultobj;
48023 fail:
48024 return NULL;
48025 }
48026
48027
48028 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48029 PyObject *obj;
48030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48031 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48032 return SWIG_Py_Void();
48033 }
48034
48035 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48036 return SWIG_Python_InitShadowInstance(args);
48037 }
48038
48039 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48040 PyObject *resultobj = 0;
48041 int arg1 = (int) 1 ;
48042 int arg2 = (int) 0 ;
48043 int arg3 = (int) 0 ;
48044 int arg4 = (int) 0 ;
48045 wxFlexGridSizer *result = 0 ;
48046 int val1 ;
48047 int ecode1 = 0 ;
48048 int val2 ;
48049 int ecode2 = 0 ;
48050 int val3 ;
48051 int ecode3 = 0 ;
48052 int val4 ;
48053 int ecode4 = 0 ;
48054 PyObject * obj0 = 0 ;
48055 PyObject * obj1 = 0 ;
48056 PyObject * obj2 = 0 ;
48057 PyObject * obj3 = 0 ;
48058 char * kwnames[] = {
48059 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48060 };
48061
48062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48063 if (obj0) {
48064 ecode1 = SWIG_AsVal_int(obj0, &val1);
48065 if (!SWIG_IsOK(ecode1)) {
48066 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48067 }
48068 arg1 = static_cast< int >(val1);
48069 }
48070 if (obj1) {
48071 ecode2 = SWIG_AsVal_int(obj1, &val2);
48072 if (!SWIG_IsOK(ecode2)) {
48073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48074 }
48075 arg2 = static_cast< int >(val2);
48076 }
48077 if (obj2) {
48078 ecode3 = SWIG_AsVal_int(obj2, &val3);
48079 if (!SWIG_IsOK(ecode3)) {
48080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48081 }
48082 arg3 = static_cast< int >(val3);
48083 }
48084 if (obj3) {
48085 ecode4 = SWIG_AsVal_int(obj3, &val4);
48086 if (!SWIG_IsOK(ecode4)) {
48087 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48088 }
48089 arg4 = static_cast< int >(val4);
48090 }
48091 {
48092 PyThreadState* __tstate = wxPyBeginAllowThreads();
48093 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48094 wxPyEndAllowThreads(__tstate);
48095 if (PyErr_Occurred()) SWIG_fail;
48096 }
48097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48098 return resultobj;
48099 fail:
48100 return NULL;
48101 }
48102
48103
48104 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48105 PyObject *resultobj = 0;
48106 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48107 size_t arg2 ;
48108 int arg3 = (int) 0 ;
48109 void *argp1 = 0 ;
48110 int res1 = 0 ;
48111 size_t val2 ;
48112 int ecode2 = 0 ;
48113 int val3 ;
48114 int ecode3 = 0 ;
48115 PyObject * obj0 = 0 ;
48116 PyObject * obj1 = 0 ;
48117 PyObject * obj2 = 0 ;
48118 char * kwnames[] = {
48119 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48120 };
48121
48122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48124 if (!SWIG_IsOK(res1)) {
48125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48126 }
48127 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48128 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48129 if (!SWIG_IsOK(ecode2)) {
48130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48131 }
48132 arg2 = static_cast< size_t >(val2);
48133 if (obj2) {
48134 ecode3 = SWIG_AsVal_int(obj2, &val3);
48135 if (!SWIG_IsOK(ecode3)) {
48136 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48137 }
48138 arg3 = static_cast< int >(val3);
48139 }
48140 {
48141 PyThreadState* __tstate = wxPyBeginAllowThreads();
48142 (arg1)->AddGrowableRow(arg2,arg3);
48143 wxPyEndAllowThreads(__tstate);
48144 if (PyErr_Occurred()) SWIG_fail;
48145 }
48146 resultobj = SWIG_Py_Void();
48147 return resultobj;
48148 fail:
48149 return NULL;
48150 }
48151
48152
48153 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48154 PyObject *resultobj = 0;
48155 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48156 size_t arg2 ;
48157 void *argp1 = 0 ;
48158 int res1 = 0 ;
48159 size_t val2 ;
48160 int ecode2 = 0 ;
48161 PyObject * obj0 = 0 ;
48162 PyObject * obj1 = 0 ;
48163 char * kwnames[] = {
48164 (char *) "self",(char *) "idx", NULL
48165 };
48166
48167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48169 if (!SWIG_IsOK(res1)) {
48170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48171 }
48172 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48173 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48174 if (!SWIG_IsOK(ecode2)) {
48175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48176 }
48177 arg2 = static_cast< size_t >(val2);
48178 {
48179 PyThreadState* __tstate = wxPyBeginAllowThreads();
48180 (arg1)->RemoveGrowableRow(arg2);
48181 wxPyEndAllowThreads(__tstate);
48182 if (PyErr_Occurred()) SWIG_fail;
48183 }
48184 resultobj = SWIG_Py_Void();
48185 return resultobj;
48186 fail:
48187 return NULL;
48188 }
48189
48190
48191 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48192 PyObject *resultobj = 0;
48193 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48194 size_t arg2 ;
48195 int arg3 = (int) 0 ;
48196 void *argp1 = 0 ;
48197 int res1 = 0 ;
48198 size_t val2 ;
48199 int ecode2 = 0 ;
48200 int val3 ;
48201 int ecode3 = 0 ;
48202 PyObject * obj0 = 0 ;
48203 PyObject * obj1 = 0 ;
48204 PyObject * obj2 = 0 ;
48205 char * kwnames[] = {
48206 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48207 };
48208
48209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48211 if (!SWIG_IsOK(res1)) {
48212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48213 }
48214 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48215 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48216 if (!SWIG_IsOK(ecode2)) {
48217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48218 }
48219 arg2 = static_cast< size_t >(val2);
48220 if (obj2) {
48221 ecode3 = SWIG_AsVal_int(obj2, &val3);
48222 if (!SWIG_IsOK(ecode3)) {
48223 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48224 }
48225 arg3 = static_cast< int >(val3);
48226 }
48227 {
48228 PyThreadState* __tstate = wxPyBeginAllowThreads();
48229 (arg1)->AddGrowableCol(arg2,arg3);
48230 wxPyEndAllowThreads(__tstate);
48231 if (PyErr_Occurred()) SWIG_fail;
48232 }
48233 resultobj = SWIG_Py_Void();
48234 return resultobj;
48235 fail:
48236 return NULL;
48237 }
48238
48239
48240 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48241 PyObject *resultobj = 0;
48242 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48243 size_t arg2 ;
48244 void *argp1 = 0 ;
48245 int res1 = 0 ;
48246 size_t val2 ;
48247 int ecode2 = 0 ;
48248 PyObject * obj0 = 0 ;
48249 PyObject * obj1 = 0 ;
48250 char * kwnames[] = {
48251 (char *) "self",(char *) "idx", NULL
48252 };
48253
48254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48256 if (!SWIG_IsOK(res1)) {
48257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48258 }
48259 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48260 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48261 if (!SWIG_IsOK(ecode2)) {
48262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48263 }
48264 arg2 = static_cast< size_t >(val2);
48265 {
48266 PyThreadState* __tstate = wxPyBeginAllowThreads();
48267 (arg1)->RemoveGrowableCol(arg2);
48268 wxPyEndAllowThreads(__tstate);
48269 if (PyErr_Occurred()) SWIG_fail;
48270 }
48271 resultobj = SWIG_Py_Void();
48272 return resultobj;
48273 fail:
48274 return NULL;
48275 }
48276
48277
48278 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48279 PyObject *resultobj = 0;
48280 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48281 int arg2 ;
48282 void *argp1 = 0 ;
48283 int res1 = 0 ;
48284 int val2 ;
48285 int ecode2 = 0 ;
48286 PyObject * obj0 = 0 ;
48287 PyObject * obj1 = 0 ;
48288 char * kwnames[] = {
48289 (char *) "self",(char *) "direction", NULL
48290 };
48291
48292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48294 if (!SWIG_IsOK(res1)) {
48295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48296 }
48297 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48298 ecode2 = SWIG_AsVal_int(obj1, &val2);
48299 if (!SWIG_IsOK(ecode2)) {
48300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48301 }
48302 arg2 = static_cast< int >(val2);
48303 {
48304 PyThreadState* __tstate = wxPyBeginAllowThreads();
48305 (arg1)->SetFlexibleDirection(arg2);
48306 wxPyEndAllowThreads(__tstate);
48307 if (PyErr_Occurred()) SWIG_fail;
48308 }
48309 resultobj = SWIG_Py_Void();
48310 return resultobj;
48311 fail:
48312 return NULL;
48313 }
48314
48315
48316 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48317 PyObject *resultobj = 0;
48318 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48319 int result;
48320 void *argp1 = 0 ;
48321 int res1 = 0 ;
48322 PyObject *swig_obj[1] ;
48323
48324 if (!args) SWIG_fail;
48325 swig_obj[0] = args;
48326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48327 if (!SWIG_IsOK(res1)) {
48328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48329 }
48330 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48331 {
48332 PyThreadState* __tstate = wxPyBeginAllowThreads();
48333 result = (int)(arg1)->GetFlexibleDirection();
48334 wxPyEndAllowThreads(__tstate);
48335 if (PyErr_Occurred()) SWIG_fail;
48336 }
48337 resultobj = SWIG_From_int(static_cast< int >(result));
48338 return resultobj;
48339 fail:
48340 return NULL;
48341 }
48342
48343
48344 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48345 PyObject *resultobj = 0;
48346 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48347 wxFlexSizerGrowMode arg2 ;
48348 void *argp1 = 0 ;
48349 int res1 = 0 ;
48350 int val2 ;
48351 int ecode2 = 0 ;
48352 PyObject * obj0 = 0 ;
48353 PyObject * obj1 = 0 ;
48354 char * kwnames[] = {
48355 (char *) "self",(char *) "mode", NULL
48356 };
48357
48358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48360 if (!SWIG_IsOK(res1)) {
48361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48362 }
48363 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48364 ecode2 = SWIG_AsVal_int(obj1, &val2);
48365 if (!SWIG_IsOK(ecode2)) {
48366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48367 }
48368 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48369 {
48370 PyThreadState* __tstate = wxPyBeginAllowThreads();
48371 (arg1)->SetNonFlexibleGrowMode(arg2);
48372 wxPyEndAllowThreads(__tstate);
48373 if (PyErr_Occurred()) SWIG_fail;
48374 }
48375 resultobj = SWIG_Py_Void();
48376 return resultobj;
48377 fail:
48378 return NULL;
48379 }
48380
48381
48382 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48383 PyObject *resultobj = 0;
48384 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48385 wxFlexSizerGrowMode result;
48386 void *argp1 = 0 ;
48387 int res1 = 0 ;
48388 PyObject *swig_obj[1] ;
48389
48390 if (!args) SWIG_fail;
48391 swig_obj[0] = args;
48392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48393 if (!SWIG_IsOK(res1)) {
48394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48395 }
48396 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48397 {
48398 PyThreadState* __tstate = wxPyBeginAllowThreads();
48399 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48400 wxPyEndAllowThreads(__tstate);
48401 if (PyErr_Occurred()) SWIG_fail;
48402 }
48403 resultobj = SWIG_From_int(static_cast< int >(result));
48404 return resultobj;
48405 fail:
48406 return NULL;
48407 }
48408
48409
48410 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48411 PyObject *resultobj = 0;
48412 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48413 wxArrayInt *result = 0 ;
48414 void *argp1 = 0 ;
48415 int res1 = 0 ;
48416 PyObject *swig_obj[1] ;
48417
48418 if (!args) SWIG_fail;
48419 swig_obj[0] = args;
48420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48421 if (!SWIG_IsOK(res1)) {
48422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48423 }
48424 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48425 {
48426 PyThreadState* __tstate = wxPyBeginAllowThreads();
48427 {
48428 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48429 result = (wxArrayInt *) &_result_ref;
48430 }
48431 wxPyEndAllowThreads(__tstate);
48432 if (PyErr_Occurred()) SWIG_fail;
48433 }
48434 {
48435 resultobj = PyList_New(0);
48436 size_t idx;
48437 for (idx = 0; idx < result->GetCount(); idx += 1) {
48438 PyObject* val = PyInt_FromLong( result->Item(idx) );
48439 PyList_Append(resultobj, val);
48440 Py_DECREF(val);
48441 }
48442 }
48443 return resultobj;
48444 fail:
48445 return NULL;
48446 }
48447
48448
48449 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48450 PyObject *resultobj = 0;
48451 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48452 wxArrayInt *result = 0 ;
48453 void *argp1 = 0 ;
48454 int res1 = 0 ;
48455 PyObject *swig_obj[1] ;
48456
48457 if (!args) SWIG_fail;
48458 swig_obj[0] = args;
48459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48460 if (!SWIG_IsOK(res1)) {
48461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48462 }
48463 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48464 {
48465 PyThreadState* __tstate = wxPyBeginAllowThreads();
48466 {
48467 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48468 result = (wxArrayInt *) &_result_ref;
48469 }
48470 wxPyEndAllowThreads(__tstate);
48471 if (PyErr_Occurred()) SWIG_fail;
48472 }
48473 {
48474 resultobj = PyList_New(0);
48475 size_t idx;
48476 for (idx = 0; idx < result->GetCount(); idx += 1) {
48477 PyObject* val = PyInt_FromLong( result->Item(idx) );
48478 PyList_Append(resultobj, val);
48479 Py_DECREF(val);
48480 }
48481 }
48482 return resultobj;
48483 fail:
48484 return NULL;
48485 }
48486
48487
48488 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48489 PyObject *obj;
48490 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48491 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48492 return SWIG_Py_Void();
48493 }
48494
48495 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48496 return SWIG_Python_InitShadowInstance(args);
48497 }
48498
48499 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48500 PyObject *resultobj = 0;
48501 wxStdDialogButtonSizer *result = 0 ;
48502
48503 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48504 {
48505 PyThreadState* __tstate = wxPyBeginAllowThreads();
48506 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48507 wxPyEndAllowThreads(__tstate);
48508 if (PyErr_Occurred()) SWIG_fail;
48509 }
48510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48511 return resultobj;
48512 fail:
48513 return NULL;
48514 }
48515
48516
48517 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48518 PyObject *resultobj = 0;
48519 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48520 wxButton *arg2 = (wxButton *) 0 ;
48521 void *argp1 = 0 ;
48522 int res1 = 0 ;
48523 void *argp2 = 0 ;
48524 int res2 = 0 ;
48525 PyObject * obj0 = 0 ;
48526 PyObject * obj1 = 0 ;
48527 char * kwnames[] = {
48528 (char *) "self",(char *) "button", NULL
48529 };
48530
48531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48533 if (!SWIG_IsOK(res1)) {
48534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48535 }
48536 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48537 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48538 if (!SWIG_IsOK(res2)) {
48539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48540 }
48541 arg2 = reinterpret_cast< wxButton * >(argp2);
48542 {
48543 PyThreadState* __tstate = wxPyBeginAllowThreads();
48544 (arg1)->AddButton(arg2);
48545 wxPyEndAllowThreads(__tstate);
48546 if (PyErr_Occurred()) SWIG_fail;
48547 }
48548 resultobj = SWIG_Py_Void();
48549 return resultobj;
48550 fail:
48551 return NULL;
48552 }
48553
48554
48555 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48556 PyObject *resultobj = 0;
48557 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48558 void *argp1 = 0 ;
48559 int res1 = 0 ;
48560 PyObject *swig_obj[1] ;
48561
48562 if (!args) SWIG_fail;
48563 swig_obj[0] = args;
48564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48565 if (!SWIG_IsOK(res1)) {
48566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48567 }
48568 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48569 {
48570 PyThreadState* __tstate = wxPyBeginAllowThreads();
48571 (arg1)->Realize();
48572 wxPyEndAllowThreads(__tstate);
48573 if (PyErr_Occurred()) SWIG_fail;
48574 }
48575 resultobj = SWIG_Py_Void();
48576 return resultobj;
48577 fail:
48578 return NULL;
48579 }
48580
48581
48582 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48583 PyObject *resultobj = 0;
48584 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48585 wxButton *arg2 = (wxButton *) 0 ;
48586 void *argp1 = 0 ;
48587 int res1 = 0 ;
48588 void *argp2 = 0 ;
48589 int res2 = 0 ;
48590 PyObject * obj0 = 0 ;
48591 PyObject * obj1 = 0 ;
48592 char * kwnames[] = {
48593 (char *) "self",(char *) "button", NULL
48594 };
48595
48596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48598 if (!SWIG_IsOK(res1)) {
48599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48600 }
48601 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48602 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48603 if (!SWIG_IsOK(res2)) {
48604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48605 }
48606 arg2 = reinterpret_cast< wxButton * >(argp2);
48607 {
48608 PyThreadState* __tstate = wxPyBeginAllowThreads();
48609 (arg1)->SetAffirmativeButton(arg2);
48610 wxPyEndAllowThreads(__tstate);
48611 if (PyErr_Occurred()) SWIG_fail;
48612 }
48613 resultobj = SWIG_Py_Void();
48614 return resultobj;
48615 fail:
48616 return NULL;
48617 }
48618
48619
48620 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48621 PyObject *resultobj = 0;
48622 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48623 wxButton *arg2 = (wxButton *) 0 ;
48624 void *argp1 = 0 ;
48625 int res1 = 0 ;
48626 void *argp2 = 0 ;
48627 int res2 = 0 ;
48628 PyObject * obj0 = 0 ;
48629 PyObject * obj1 = 0 ;
48630 char * kwnames[] = {
48631 (char *) "self",(char *) "button", NULL
48632 };
48633
48634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48636 if (!SWIG_IsOK(res1)) {
48637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48638 }
48639 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48640 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48641 if (!SWIG_IsOK(res2)) {
48642 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48643 }
48644 arg2 = reinterpret_cast< wxButton * >(argp2);
48645 {
48646 PyThreadState* __tstate = wxPyBeginAllowThreads();
48647 (arg1)->SetNegativeButton(arg2);
48648 wxPyEndAllowThreads(__tstate);
48649 if (PyErr_Occurred()) SWIG_fail;
48650 }
48651 resultobj = SWIG_Py_Void();
48652 return resultobj;
48653 fail:
48654 return NULL;
48655 }
48656
48657
48658 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48659 PyObject *resultobj = 0;
48660 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48661 wxButton *arg2 = (wxButton *) 0 ;
48662 void *argp1 = 0 ;
48663 int res1 = 0 ;
48664 void *argp2 = 0 ;
48665 int res2 = 0 ;
48666 PyObject * obj0 = 0 ;
48667 PyObject * obj1 = 0 ;
48668 char * kwnames[] = {
48669 (char *) "self",(char *) "button", NULL
48670 };
48671
48672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48674 if (!SWIG_IsOK(res1)) {
48675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48676 }
48677 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48678 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48679 if (!SWIG_IsOK(res2)) {
48680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48681 }
48682 arg2 = reinterpret_cast< wxButton * >(argp2);
48683 {
48684 PyThreadState* __tstate = wxPyBeginAllowThreads();
48685 (arg1)->SetCancelButton(arg2);
48686 wxPyEndAllowThreads(__tstate);
48687 if (PyErr_Occurred()) SWIG_fail;
48688 }
48689 resultobj = SWIG_Py_Void();
48690 return resultobj;
48691 fail:
48692 return NULL;
48693 }
48694
48695
48696 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48697 PyObject *resultobj = 0;
48698 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48699 wxButton *result = 0 ;
48700 void *argp1 = 0 ;
48701 int res1 = 0 ;
48702 PyObject *swig_obj[1] ;
48703
48704 if (!args) SWIG_fail;
48705 swig_obj[0] = args;
48706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48707 if (!SWIG_IsOK(res1)) {
48708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48709 }
48710 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48711 {
48712 PyThreadState* __tstate = wxPyBeginAllowThreads();
48713 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48714 wxPyEndAllowThreads(__tstate);
48715 if (PyErr_Occurred()) SWIG_fail;
48716 }
48717 {
48718 resultobj = wxPyMake_wxObject(result, (bool)0);
48719 }
48720 return resultobj;
48721 fail:
48722 return NULL;
48723 }
48724
48725
48726 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48727 PyObject *resultobj = 0;
48728 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48729 wxButton *result = 0 ;
48730 void *argp1 = 0 ;
48731 int res1 = 0 ;
48732 PyObject *swig_obj[1] ;
48733
48734 if (!args) SWIG_fail;
48735 swig_obj[0] = args;
48736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48737 if (!SWIG_IsOK(res1)) {
48738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48739 }
48740 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48741 {
48742 PyThreadState* __tstate = wxPyBeginAllowThreads();
48743 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48744 wxPyEndAllowThreads(__tstate);
48745 if (PyErr_Occurred()) SWIG_fail;
48746 }
48747 {
48748 resultobj = wxPyMake_wxObject(result, (bool)0);
48749 }
48750 return resultobj;
48751 fail:
48752 return NULL;
48753 }
48754
48755
48756 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48757 PyObject *resultobj = 0;
48758 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48759 wxButton *result = 0 ;
48760 void *argp1 = 0 ;
48761 int res1 = 0 ;
48762 PyObject *swig_obj[1] ;
48763
48764 if (!args) SWIG_fail;
48765 swig_obj[0] = args;
48766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48767 if (!SWIG_IsOK(res1)) {
48768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48769 }
48770 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48771 {
48772 PyThreadState* __tstate = wxPyBeginAllowThreads();
48773 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48774 wxPyEndAllowThreads(__tstate);
48775 if (PyErr_Occurred()) SWIG_fail;
48776 }
48777 {
48778 resultobj = wxPyMake_wxObject(result, (bool)0);
48779 }
48780 return resultobj;
48781 fail:
48782 return NULL;
48783 }
48784
48785
48786 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48787 PyObject *resultobj = 0;
48788 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48789 wxButton *result = 0 ;
48790 void *argp1 = 0 ;
48791 int res1 = 0 ;
48792 PyObject *swig_obj[1] ;
48793
48794 if (!args) SWIG_fail;
48795 swig_obj[0] = args;
48796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48797 if (!SWIG_IsOK(res1)) {
48798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48799 }
48800 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48801 {
48802 PyThreadState* __tstate = wxPyBeginAllowThreads();
48803 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48804 wxPyEndAllowThreads(__tstate);
48805 if (PyErr_Occurred()) SWIG_fail;
48806 }
48807 {
48808 resultobj = wxPyMake_wxObject(result, (bool)0);
48809 }
48810 return resultobj;
48811 fail:
48812 return NULL;
48813 }
48814
48815
48816 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48817 PyObject *resultobj = 0;
48818 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48819 wxButton *result = 0 ;
48820 void *argp1 = 0 ;
48821 int res1 = 0 ;
48822 PyObject *swig_obj[1] ;
48823
48824 if (!args) SWIG_fail;
48825 swig_obj[0] = args;
48826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48827 if (!SWIG_IsOK(res1)) {
48828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48829 }
48830 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48831 {
48832 PyThreadState* __tstate = wxPyBeginAllowThreads();
48833 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48834 wxPyEndAllowThreads(__tstate);
48835 if (PyErr_Occurred()) SWIG_fail;
48836 }
48837 {
48838 resultobj = wxPyMake_wxObject(result, (bool)0);
48839 }
48840 return resultobj;
48841 fail:
48842 return NULL;
48843 }
48844
48845
48846 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48847 PyObject *obj;
48848 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48849 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48850 return SWIG_Py_Void();
48851 }
48852
48853 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48854 return SWIG_Python_InitShadowInstance(args);
48855 }
48856
48857 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48858 PyObject *resultobj = 0;
48859 int arg1 = (int) 0 ;
48860 int arg2 = (int) 0 ;
48861 wxGBPosition *result = 0 ;
48862 int val1 ;
48863 int ecode1 = 0 ;
48864 int val2 ;
48865 int ecode2 = 0 ;
48866 PyObject * obj0 = 0 ;
48867 PyObject * obj1 = 0 ;
48868 char * kwnames[] = {
48869 (char *) "row",(char *) "col", NULL
48870 };
48871
48872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48873 if (obj0) {
48874 ecode1 = SWIG_AsVal_int(obj0, &val1);
48875 if (!SWIG_IsOK(ecode1)) {
48876 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48877 }
48878 arg1 = static_cast< int >(val1);
48879 }
48880 if (obj1) {
48881 ecode2 = SWIG_AsVal_int(obj1, &val2);
48882 if (!SWIG_IsOK(ecode2)) {
48883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48884 }
48885 arg2 = static_cast< int >(val2);
48886 }
48887 {
48888 PyThreadState* __tstate = wxPyBeginAllowThreads();
48889 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48890 wxPyEndAllowThreads(__tstate);
48891 if (PyErr_Occurred()) SWIG_fail;
48892 }
48893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48894 return resultobj;
48895 fail:
48896 return NULL;
48897 }
48898
48899
48900 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48901 PyObject *resultobj = 0;
48902 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48903 void *argp1 = 0 ;
48904 int res1 = 0 ;
48905 PyObject *swig_obj[1] ;
48906
48907 if (!args) SWIG_fail;
48908 swig_obj[0] = args;
48909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48910 if (!SWIG_IsOK(res1)) {
48911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48912 }
48913 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48914 {
48915 PyThreadState* __tstate = wxPyBeginAllowThreads();
48916 delete arg1;
48917
48918 wxPyEndAllowThreads(__tstate);
48919 if (PyErr_Occurred()) SWIG_fail;
48920 }
48921 resultobj = SWIG_Py_Void();
48922 return resultobj;
48923 fail:
48924 return NULL;
48925 }
48926
48927
48928 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48929 PyObject *resultobj = 0;
48930 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48931 int result;
48932 void *argp1 = 0 ;
48933 int res1 = 0 ;
48934 PyObject *swig_obj[1] ;
48935
48936 if (!args) SWIG_fail;
48937 swig_obj[0] = args;
48938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48939 if (!SWIG_IsOK(res1)) {
48940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48941 }
48942 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48943 {
48944 PyThreadState* __tstate = wxPyBeginAllowThreads();
48945 result = (int)((wxGBPosition const *)arg1)->GetRow();
48946 wxPyEndAllowThreads(__tstate);
48947 if (PyErr_Occurred()) SWIG_fail;
48948 }
48949 resultobj = SWIG_From_int(static_cast< int >(result));
48950 return resultobj;
48951 fail:
48952 return NULL;
48953 }
48954
48955
48956 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48957 PyObject *resultobj = 0;
48958 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48959 int result;
48960 void *argp1 = 0 ;
48961 int res1 = 0 ;
48962 PyObject *swig_obj[1] ;
48963
48964 if (!args) SWIG_fail;
48965 swig_obj[0] = args;
48966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48967 if (!SWIG_IsOK(res1)) {
48968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48969 }
48970 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48971 {
48972 PyThreadState* __tstate = wxPyBeginAllowThreads();
48973 result = (int)((wxGBPosition const *)arg1)->GetCol();
48974 wxPyEndAllowThreads(__tstate);
48975 if (PyErr_Occurred()) SWIG_fail;
48976 }
48977 resultobj = SWIG_From_int(static_cast< int >(result));
48978 return resultobj;
48979 fail:
48980 return NULL;
48981 }
48982
48983
48984 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48985 PyObject *resultobj = 0;
48986 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48987 int arg2 ;
48988 void *argp1 = 0 ;
48989 int res1 = 0 ;
48990 int val2 ;
48991 int ecode2 = 0 ;
48992 PyObject * obj0 = 0 ;
48993 PyObject * obj1 = 0 ;
48994 char * kwnames[] = {
48995 (char *) "self",(char *) "row", NULL
48996 };
48997
48998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49000 if (!SWIG_IsOK(res1)) {
49001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49002 }
49003 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49004 ecode2 = SWIG_AsVal_int(obj1, &val2);
49005 if (!SWIG_IsOK(ecode2)) {
49006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49007 }
49008 arg2 = static_cast< int >(val2);
49009 {
49010 PyThreadState* __tstate = wxPyBeginAllowThreads();
49011 (arg1)->SetRow(arg2);
49012 wxPyEndAllowThreads(__tstate);
49013 if (PyErr_Occurred()) SWIG_fail;
49014 }
49015 resultobj = SWIG_Py_Void();
49016 return resultobj;
49017 fail:
49018 return NULL;
49019 }
49020
49021
49022 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49023 PyObject *resultobj = 0;
49024 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49025 int arg2 ;
49026 void *argp1 = 0 ;
49027 int res1 = 0 ;
49028 int val2 ;
49029 int ecode2 = 0 ;
49030 PyObject * obj0 = 0 ;
49031 PyObject * obj1 = 0 ;
49032 char * kwnames[] = {
49033 (char *) "self",(char *) "col", NULL
49034 };
49035
49036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49038 if (!SWIG_IsOK(res1)) {
49039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49040 }
49041 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49042 ecode2 = SWIG_AsVal_int(obj1, &val2);
49043 if (!SWIG_IsOK(ecode2)) {
49044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49045 }
49046 arg2 = static_cast< int >(val2);
49047 {
49048 PyThreadState* __tstate = wxPyBeginAllowThreads();
49049 (arg1)->SetCol(arg2);
49050 wxPyEndAllowThreads(__tstate);
49051 if (PyErr_Occurred()) SWIG_fail;
49052 }
49053 resultobj = SWIG_Py_Void();
49054 return resultobj;
49055 fail:
49056 return NULL;
49057 }
49058
49059
49060 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49061 PyObject *resultobj = 0;
49062 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49063 PyObject *arg2 = (PyObject *) 0 ;
49064 bool result;
49065 void *argp1 = 0 ;
49066 int res1 = 0 ;
49067 PyObject * obj0 = 0 ;
49068 PyObject * obj1 = 0 ;
49069 char * kwnames[] = {
49070 (char *) "self",(char *) "other", NULL
49071 };
49072
49073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49075 if (!SWIG_IsOK(res1)) {
49076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49077 }
49078 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49079 arg2 = obj1;
49080 {
49081 result = (bool)wxGBPosition___eq__(arg1,arg2);
49082 if (PyErr_Occurred()) SWIG_fail;
49083 }
49084 {
49085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49086 }
49087 return resultobj;
49088 fail:
49089 return NULL;
49090 }
49091
49092
49093 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49094 PyObject *resultobj = 0;
49095 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49096 PyObject *arg2 = (PyObject *) 0 ;
49097 bool result;
49098 void *argp1 = 0 ;
49099 int res1 = 0 ;
49100 PyObject * obj0 = 0 ;
49101 PyObject * obj1 = 0 ;
49102 char * kwnames[] = {
49103 (char *) "self",(char *) "other", NULL
49104 };
49105
49106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49108 if (!SWIG_IsOK(res1)) {
49109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49110 }
49111 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49112 arg2 = obj1;
49113 {
49114 result = (bool)wxGBPosition___ne__(arg1,arg2);
49115 if (PyErr_Occurred()) SWIG_fail;
49116 }
49117 {
49118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49119 }
49120 return resultobj;
49121 fail:
49122 return NULL;
49123 }
49124
49125
49126 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49127 PyObject *resultobj = 0;
49128 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49129 int arg2 = (int) 0 ;
49130 int arg3 = (int) 0 ;
49131 void *argp1 = 0 ;
49132 int res1 = 0 ;
49133 int val2 ;
49134 int ecode2 = 0 ;
49135 int val3 ;
49136 int ecode3 = 0 ;
49137 PyObject * obj0 = 0 ;
49138 PyObject * obj1 = 0 ;
49139 PyObject * obj2 = 0 ;
49140 char * kwnames[] = {
49141 (char *) "self",(char *) "row",(char *) "col", NULL
49142 };
49143
49144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49146 if (!SWIG_IsOK(res1)) {
49147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49148 }
49149 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49150 if (obj1) {
49151 ecode2 = SWIG_AsVal_int(obj1, &val2);
49152 if (!SWIG_IsOK(ecode2)) {
49153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49154 }
49155 arg2 = static_cast< int >(val2);
49156 }
49157 if (obj2) {
49158 ecode3 = SWIG_AsVal_int(obj2, &val3);
49159 if (!SWIG_IsOK(ecode3)) {
49160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49161 }
49162 arg3 = static_cast< int >(val3);
49163 }
49164 {
49165 PyThreadState* __tstate = wxPyBeginAllowThreads();
49166 wxGBPosition_Set(arg1,arg2,arg3);
49167 wxPyEndAllowThreads(__tstate);
49168 if (PyErr_Occurred()) SWIG_fail;
49169 }
49170 resultobj = SWIG_Py_Void();
49171 return resultobj;
49172 fail:
49173 return NULL;
49174 }
49175
49176
49177 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49178 PyObject *resultobj = 0;
49179 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49180 PyObject *result = 0 ;
49181 void *argp1 = 0 ;
49182 int res1 = 0 ;
49183 PyObject *swig_obj[1] ;
49184
49185 if (!args) SWIG_fail;
49186 swig_obj[0] = args;
49187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49188 if (!SWIG_IsOK(res1)) {
49189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49190 }
49191 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49192 {
49193 PyThreadState* __tstate = wxPyBeginAllowThreads();
49194 result = (PyObject *)wxGBPosition_Get(arg1);
49195 wxPyEndAllowThreads(__tstate);
49196 if (PyErr_Occurred()) SWIG_fail;
49197 }
49198 resultobj = result;
49199 return resultobj;
49200 fail:
49201 return NULL;
49202 }
49203
49204
49205 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49206 PyObject *obj;
49207 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49208 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49209 return SWIG_Py_Void();
49210 }
49211
49212 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49213 return SWIG_Python_InitShadowInstance(args);
49214 }
49215
49216 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49217 PyObject *resultobj = 0;
49218 int arg1 = (int) 1 ;
49219 int arg2 = (int) 1 ;
49220 wxGBSpan *result = 0 ;
49221 int val1 ;
49222 int ecode1 = 0 ;
49223 int val2 ;
49224 int ecode2 = 0 ;
49225 PyObject * obj0 = 0 ;
49226 PyObject * obj1 = 0 ;
49227 char * kwnames[] = {
49228 (char *) "rowspan",(char *) "colspan", NULL
49229 };
49230
49231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49232 if (obj0) {
49233 ecode1 = SWIG_AsVal_int(obj0, &val1);
49234 if (!SWIG_IsOK(ecode1)) {
49235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49236 }
49237 arg1 = static_cast< int >(val1);
49238 }
49239 if (obj1) {
49240 ecode2 = SWIG_AsVal_int(obj1, &val2);
49241 if (!SWIG_IsOK(ecode2)) {
49242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49243 }
49244 arg2 = static_cast< int >(val2);
49245 }
49246 {
49247 PyThreadState* __tstate = wxPyBeginAllowThreads();
49248 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49249 wxPyEndAllowThreads(__tstate);
49250 if (PyErr_Occurred()) SWIG_fail;
49251 }
49252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49253 return resultobj;
49254 fail:
49255 return NULL;
49256 }
49257
49258
49259 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49260 PyObject *resultobj = 0;
49261 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49262 void *argp1 = 0 ;
49263 int res1 = 0 ;
49264 PyObject *swig_obj[1] ;
49265
49266 if (!args) SWIG_fail;
49267 swig_obj[0] = args;
49268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49269 if (!SWIG_IsOK(res1)) {
49270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49271 }
49272 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49273 {
49274 PyThreadState* __tstate = wxPyBeginAllowThreads();
49275 delete arg1;
49276
49277 wxPyEndAllowThreads(__tstate);
49278 if (PyErr_Occurred()) SWIG_fail;
49279 }
49280 resultobj = SWIG_Py_Void();
49281 return resultobj;
49282 fail:
49283 return NULL;
49284 }
49285
49286
49287 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49288 PyObject *resultobj = 0;
49289 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49290 int result;
49291 void *argp1 = 0 ;
49292 int res1 = 0 ;
49293 PyObject *swig_obj[1] ;
49294
49295 if (!args) SWIG_fail;
49296 swig_obj[0] = args;
49297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49298 if (!SWIG_IsOK(res1)) {
49299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49300 }
49301 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49302 {
49303 PyThreadState* __tstate = wxPyBeginAllowThreads();
49304 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49305 wxPyEndAllowThreads(__tstate);
49306 if (PyErr_Occurred()) SWIG_fail;
49307 }
49308 resultobj = SWIG_From_int(static_cast< int >(result));
49309 return resultobj;
49310 fail:
49311 return NULL;
49312 }
49313
49314
49315 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49316 PyObject *resultobj = 0;
49317 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49318 int result;
49319 void *argp1 = 0 ;
49320 int res1 = 0 ;
49321 PyObject *swig_obj[1] ;
49322
49323 if (!args) SWIG_fail;
49324 swig_obj[0] = args;
49325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49326 if (!SWIG_IsOK(res1)) {
49327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49328 }
49329 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49330 {
49331 PyThreadState* __tstate = wxPyBeginAllowThreads();
49332 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49333 wxPyEndAllowThreads(__tstate);
49334 if (PyErr_Occurred()) SWIG_fail;
49335 }
49336 resultobj = SWIG_From_int(static_cast< int >(result));
49337 return resultobj;
49338 fail:
49339 return NULL;
49340 }
49341
49342
49343 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49344 PyObject *resultobj = 0;
49345 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49346 int arg2 ;
49347 void *argp1 = 0 ;
49348 int res1 = 0 ;
49349 int val2 ;
49350 int ecode2 = 0 ;
49351 PyObject * obj0 = 0 ;
49352 PyObject * obj1 = 0 ;
49353 char * kwnames[] = {
49354 (char *) "self",(char *) "rowspan", NULL
49355 };
49356
49357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49359 if (!SWIG_IsOK(res1)) {
49360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49361 }
49362 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49363 ecode2 = SWIG_AsVal_int(obj1, &val2);
49364 if (!SWIG_IsOK(ecode2)) {
49365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49366 }
49367 arg2 = static_cast< int >(val2);
49368 {
49369 PyThreadState* __tstate = wxPyBeginAllowThreads();
49370 (arg1)->SetRowspan(arg2);
49371 wxPyEndAllowThreads(__tstate);
49372 if (PyErr_Occurred()) SWIG_fail;
49373 }
49374 resultobj = SWIG_Py_Void();
49375 return resultobj;
49376 fail:
49377 return NULL;
49378 }
49379
49380
49381 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49382 PyObject *resultobj = 0;
49383 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49384 int arg2 ;
49385 void *argp1 = 0 ;
49386 int res1 = 0 ;
49387 int val2 ;
49388 int ecode2 = 0 ;
49389 PyObject * obj0 = 0 ;
49390 PyObject * obj1 = 0 ;
49391 char * kwnames[] = {
49392 (char *) "self",(char *) "colspan", NULL
49393 };
49394
49395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49397 if (!SWIG_IsOK(res1)) {
49398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49399 }
49400 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49401 ecode2 = SWIG_AsVal_int(obj1, &val2);
49402 if (!SWIG_IsOK(ecode2)) {
49403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49404 }
49405 arg2 = static_cast< int >(val2);
49406 {
49407 PyThreadState* __tstate = wxPyBeginAllowThreads();
49408 (arg1)->SetColspan(arg2);
49409 wxPyEndAllowThreads(__tstate);
49410 if (PyErr_Occurred()) SWIG_fail;
49411 }
49412 resultobj = SWIG_Py_Void();
49413 return resultobj;
49414 fail:
49415 return NULL;
49416 }
49417
49418
49419 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49420 PyObject *resultobj = 0;
49421 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49422 PyObject *arg2 = (PyObject *) 0 ;
49423 bool result;
49424 void *argp1 = 0 ;
49425 int res1 = 0 ;
49426 PyObject * obj0 = 0 ;
49427 PyObject * obj1 = 0 ;
49428 char * kwnames[] = {
49429 (char *) "self",(char *) "other", NULL
49430 };
49431
49432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49434 if (!SWIG_IsOK(res1)) {
49435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49436 }
49437 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49438 arg2 = obj1;
49439 {
49440 result = (bool)wxGBSpan___eq__(arg1,arg2);
49441 if (PyErr_Occurred()) SWIG_fail;
49442 }
49443 {
49444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49445 }
49446 return resultobj;
49447 fail:
49448 return NULL;
49449 }
49450
49451
49452 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49453 PyObject *resultobj = 0;
49454 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49455 PyObject *arg2 = (PyObject *) 0 ;
49456 bool result;
49457 void *argp1 = 0 ;
49458 int res1 = 0 ;
49459 PyObject * obj0 = 0 ;
49460 PyObject * obj1 = 0 ;
49461 char * kwnames[] = {
49462 (char *) "self",(char *) "other", NULL
49463 };
49464
49465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49467 if (!SWIG_IsOK(res1)) {
49468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49469 }
49470 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49471 arg2 = obj1;
49472 {
49473 result = (bool)wxGBSpan___ne__(arg1,arg2);
49474 if (PyErr_Occurred()) SWIG_fail;
49475 }
49476 {
49477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49478 }
49479 return resultobj;
49480 fail:
49481 return NULL;
49482 }
49483
49484
49485 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49486 PyObject *resultobj = 0;
49487 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49488 int arg2 = (int) 1 ;
49489 int arg3 = (int) 1 ;
49490 void *argp1 = 0 ;
49491 int res1 = 0 ;
49492 int val2 ;
49493 int ecode2 = 0 ;
49494 int val3 ;
49495 int ecode3 = 0 ;
49496 PyObject * obj0 = 0 ;
49497 PyObject * obj1 = 0 ;
49498 PyObject * obj2 = 0 ;
49499 char * kwnames[] = {
49500 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49501 };
49502
49503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49505 if (!SWIG_IsOK(res1)) {
49506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49507 }
49508 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49509 if (obj1) {
49510 ecode2 = SWIG_AsVal_int(obj1, &val2);
49511 if (!SWIG_IsOK(ecode2)) {
49512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49513 }
49514 arg2 = static_cast< int >(val2);
49515 }
49516 if (obj2) {
49517 ecode3 = SWIG_AsVal_int(obj2, &val3);
49518 if (!SWIG_IsOK(ecode3)) {
49519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49520 }
49521 arg3 = static_cast< int >(val3);
49522 }
49523 {
49524 PyThreadState* __tstate = wxPyBeginAllowThreads();
49525 wxGBSpan_Set(arg1,arg2,arg3);
49526 wxPyEndAllowThreads(__tstate);
49527 if (PyErr_Occurred()) SWIG_fail;
49528 }
49529 resultobj = SWIG_Py_Void();
49530 return resultobj;
49531 fail:
49532 return NULL;
49533 }
49534
49535
49536 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49537 PyObject *resultobj = 0;
49538 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49539 PyObject *result = 0 ;
49540 void *argp1 = 0 ;
49541 int res1 = 0 ;
49542 PyObject *swig_obj[1] ;
49543
49544 if (!args) SWIG_fail;
49545 swig_obj[0] = args;
49546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49547 if (!SWIG_IsOK(res1)) {
49548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49549 }
49550 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49551 {
49552 PyThreadState* __tstate = wxPyBeginAllowThreads();
49553 result = (PyObject *)wxGBSpan_Get(arg1);
49554 wxPyEndAllowThreads(__tstate);
49555 if (PyErr_Occurred()) SWIG_fail;
49556 }
49557 resultobj = result;
49558 return resultobj;
49559 fail:
49560 return NULL;
49561 }
49562
49563
49564 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49565 PyObject *obj;
49566 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49567 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49568 return SWIG_Py_Void();
49569 }
49570
49571 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49572 return SWIG_Python_InitShadowInstance(args);
49573 }
49574
49575 SWIGINTERN int DefaultSpan_set(PyObject *) {
49576 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49577 return 1;
49578 }
49579
49580
49581 SWIGINTERN PyObject *DefaultSpan_get(void) {
49582 PyObject *pyobj = 0;
49583
49584 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49585 return pyobj;
49586 }
49587
49588
49589 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49590 PyObject *resultobj = 0;
49591 wxGBSizerItem *result = 0 ;
49592
49593 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49594 {
49595 PyThreadState* __tstate = wxPyBeginAllowThreads();
49596 result = (wxGBSizerItem *)new wxGBSizerItem();
49597 wxPyEndAllowThreads(__tstate);
49598 if (PyErr_Occurred()) SWIG_fail;
49599 }
49600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49601 return resultobj;
49602 fail:
49603 return NULL;
49604 }
49605
49606
49607 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49608 PyObject *resultobj = 0;
49609 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49610 void *argp1 = 0 ;
49611 int res1 = 0 ;
49612 PyObject *swig_obj[1] ;
49613
49614 if (!args) SWIG_fail;
49615 swig_obj[0] = args;
49616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49617 if (!SWIG_IsOK(res1)) {
49618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49619 }
49620 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49621 {
49622 PyThreadState* __tstate = wxPyBeginAllowThreads();
49623 delete arg1;
49624
49625 wxPyEndAllowThreads(__tstate);
49626 if (PyErr_Occurred()) SWIG_fail;
49627 }
49628 resultobj = SWIG_Py_Void();
49629 return resultobj;
49630 fail:
49631 return NULL;
49632 }
49633
49634
49635 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49636 PyObject *resultobj = 0;
49637 wxWindow *arg1 = (wxWindow *) 0 ;
49638 wxGBPosition *arg2 = 0 ;
49639 wxGBSpan *arg3 = 0 ;
49640 int arg4 ;
49641 int arg5 ;
49642 PyObject *arg6 = (PyObject *) NULL ;
49643 wxGBSizerItem *result = 0 ;
49644 void *argp1 = 0 ;
49645 int res1 = 0 ;
49646 wxGBPosition temp2 ;
49647 wxGBSpan temp3 ;
49648 int val4 ;
49649 int ecode4 = 0 ;
49650 int val5 ;
49651 int ecode5 = 0 ;
49652 PyObject * obj0 = 0 ;
49653 PyObject * obj1 = 0 ;
49654 PyObject * obj2 = 0 ;
49655 PyObject * obj3 = 0 ;
49656 PyObject * obj4 = 0 ;
49657 PyObject * obj5 = 0 ;
49658 char * kwnames[] = {
49659 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49660 };
49661
49662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49664 if (!SWIG_IsOK(res1)) {
49665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49666 }
49667 arg1 = reinterpret_cast< wxWindow * >(argp1);
49668 {
49669 arg2 = &temp2;
49670 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49671 }
49672 {
49673 arg3 = &temp3;
49674 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49675 }
49676 ecode4 = SWIG_AsVal_int(obj3, &val4);
49677 if (!SWIG_IsOK(ecode4)) {
49678 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49679 }
49680 arg4 = static_cast< int >(val4);
49681 ecode5 = SWIG_AsVal_int(obj4, &val5);
49682 if (!SWIG_IsOK(ecode5)) {
49683 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49684 }
49685 arg5 = static_cast< int >(val5);
49686 if (obj5) {
49687 arg6 = obj5;
49688 }
49689 {
49690 PyThreadState* __tstate = wxPyBeginAllowThreads();
49691 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49692 wxPyEndAllowThreads(__tstate);
49693 if (PyErr_Occurred()) SWIG_fail;
49694 }
49695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49696 return resultobj;
49697 fail:
49698 return NULL;
49699 }
49700
49701
49702 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49703 PyObject *resultobj = 0;
49704 wxSizer *arg1 = (wxSizer *) 0 ;
49705 wxGBPosition *arg2 = 0 ;
49706 wxGBSpan *arg3 = 0 ;
49707 int arg4 ;
49708 int arg5 ;
49709 PyObject *arg6 = (PyObject *) NULL ;
49710 wxGBSizerItem *result = 0 ;
49711 int res1 = 0 ;
49712 wxGBPosition temp2 ;
49713 wxGBSpan temp3 ;
49714 int val4 ;
49715 int ecode4 = 0 ;
49716 int val5 ;
49717 int ecode5 = 0 ;
49718 PyObject * obj0 = 0 ;
49719 PyObject * obj1 = 0 ;
49720 PyObject * obj2 = 0 ;
49721 PyObject * obj3 = 0 ;
49722 PyObject * obj4 = 0 ;
49723 PyObject * obj5 = 0 ;
49724 char * kwnames[] = {
49725 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49726 };
49727
49728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49729 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49730 if (!SWIG_IsOK(res1)) {
49731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49732 }
49733 {
49734 arg2 = &temp2;
49735 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49736 }
49737 {
49738 arg3 = &temp3;
49739 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49740 }
49741 ecode4 = SWIG_AsVal_int(obj3, &val4);
49742 if (!SWIG_IsOK(ecode4)) {
49743 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49744 }
49745 arg4 = static_cast< int >(val4);
49746 ecode5 = SWIG_AsVal_int(obj4, &val5);
49747 if (!SWIG_IsOK(ecode5)) {
49748 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49749 }
49750 arg5 = static_cast< int >(val5);
49751 if (obj5) {
49752 arg6 = obj5;
49753 }
49754 {
49755 PyThreadState* __tstate = wxPyBeginAllowThreads();
49756 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49757 wxPyEndAllowThreads(__tstate);
49758 if (PyErr_Occurred()) SWIG_fail;
49759 }
49760 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49761 return resultobj;
49762 fail:
49763 return NULL;
49764 }
49765
49766
49767 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49768 PyObject *resultobj = 0;
49769 int arg1 ;
49770 int arg2 ;
49771 wxGBPosition *arg3 = 0 ;
49772 wxGBSpan *arg4 = 0 ;
49773 int arg5 ;
49774 int arg6 ;
49775 PyObject *arg7 = (PyObject *) NULL ;
49776 wxGBSizerItem *result = 0 ;
49777 int val1 ;
49778 int ecode1 = 0 ;
49779 int val2 ;
49780 int ecode2 = 0 ;
49781 wxGBPosition temp3 ;
49782 wxGBSpan temp4 ;
49783 int val5 ;
49784 int ecode5 = 0 ;
49785 int val6 ;
49786 int ecode6 = 0 ;
49787 PyObject * obj0 = 0 ;
49788 PyObject * obj1 = 0 ;
49789 PyObject * obj2 = 0 ;
49790 PyObject * obj3 = 0 ;
49791 PyObject * obj4 = 0 ;
49792 PyObject * obj5 = 0 ;
49793 PyObject * obj6 = 0 ;
49794 char * kwnames[] = {
49795 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49796 };
49797
49798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49799 ecode1 = SWIG_AsVal_int(obj0, &val1);
49800 if (!SWIG_IsOK(ecode1)) {
49801 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49802 }
49803 arg1 = static_cast< int >(val1);
49804 ecode2 = SWIG_AsVal_int(obj1, &val2);
49805 if (!SWIG_IsOK(ecode2)) {
49806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49807 }
49808 arg2 = static_cast< int >(val2);
49809 {
49810 arg3 = &temp3;
49811 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49812 }
49813 {
49814 arg4 = &temp4;
49815 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49816 }
49817 ecode5 = SWIG_AsVal_int(obj4, &val5);
49818 if (!SWIG_IsOK(ecode5)) {
49819 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49820 }
49821 arg5 = static_cast< int >(val5);
49822 ecode6 = SWIG_AsVal_int(obj5, &val6);
49823 if (!SWIG_IsOK(ecode6)) {
49824 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49825 }
49826 arg6 = static_cast< int >(val6);
49827 if (obj6) {
49828 arg7 = obj6;
49829 }
49830 {
49831 PyThreadState* __tstate = wxPyBeginAllowThreads();
49832 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49833 wxPyEndAllowThreads(__tstate);
49834 if (PyErr_Occurred()) SWIG_fail;
49835 }
49836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49837 return resultobj;
49838 fail:
49839 return NULL;
49840 }
49841
49842
49843 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49844 PyObject *resultobj = 0;
49845 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49846 wxGBPosition result;
49847 void *argp1 = 0 ;
49848 int res1 = 0 ;
49849 PyObject *swig_obj[1] ;
49850
49851 if (!args) SWIG_fail;
49852 swig_obj[0] = args;
49853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49854 if (!SWIG_IsOK(res1)) {
49855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49856 }
49857 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49858 {
49859 PyThreadState* __tstate = wxPyBeginAllowThreads();
49860 result = ((wxGBSizerItem const *)arg1)->GetPos();
49861 wxPyEndAllowThreads(__tstate);
49862 if (PyErr_Occurred()) SWIG_fail;
49863 }
49864 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49865 return resultobj;
49866 fail:
49867 return NULL;
49868 }
49869
49870
49871 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49872 PyObject *resultobj = 0;
49873 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49874 wxGBSpan result;
49875 void *argp1 = 0 ;
49876 int res1 = 0 ;
49877 PyObject *swig_obj[1] ;
49878
49879 if (!args) SWIG_fail;
49880 swig_obj[0] = args;
49881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49882 if (!SWIG_IsOK(res1)) {
49883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49884 }
49885 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49886 {
49887 PyThreadState* __tstate = wxPyBeginAllowThreads();
49888 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49889 wxPyEndAllowThreads(__tstate);
49890 if (PyErr_Occurred()) SWIG_fail;
49891 }
49892 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49893 return resultobj;
49894 fail:
49895 return NULL;
49896 }
49897
49898
49899 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49900 PyObject *resultobj = 0;
49901 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49902 wxGBPosition *arg2 = 0 ;
49903 bool result;
49904 void *argp1 = 0 ;
49905 int res1 = 0 ;
49906 wxGBPosition temp2 ;
49907 PyObject * obj0 = 0 ;
49908 PyObject * obj1 = 0 ;
49909 char * kwnames[] = {
49910 (char *) "self",(char *) "pos", NULL
49911 };
49912
49913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49915 if (!SWIG_IsOK(res1)) {
49916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49917 }
49918 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49919 {
49920 arg2 = &temp2;
49921 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49922 }
49923 {
49924 PyThreadState* __tstate = wxPyBeginAllowThreads();
49925 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49926 wxPyEndAllowThreads(__tstate);
49927 if (PyErr_Occurred()) SWIG_fail;
49928 }
49929 {
49930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49931 }
49932 return resultobj;
49933 fail:
49934 return NULL;
49935 }
49936
49937
49938 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49939 PyObject *resultobj = 0;
49940 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49941 wxGBSpan *arg2 = 0 ;
49942 bool result;
49943 void *argp1 = 0 ;
49944 int res1 = 0 ;
49945 wxGBSpan temp2 ;
49946 PyObject * obj0 = 0 ;
49947 PyObject * obj1 = 0 ;
49948 char * kwnames[] = {
49949 (char *) "self",(char *) "span", NULL
49950 };
49951
49952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49954 if (!SWIG_IsOK(res1)) {
49955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49956 }
49957 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49958 {
49959 arg2 = &temp2;
49960 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49961 }
49962 {
49963 PyThreadState* __tstate = wxPyBeginAllowThreads();
49964 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49965 wxPyEndAllowThreads(__tstate);
49966 if (PyErr_Occurred()) SWIG_fail;
49967 }
49968 {
49969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49970 }
49971 return resultobj;
49972 fail:
49973 return NULL;
49974 }
49975
49976
49977 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49978 PyObject *resultobj = 0;
49979 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49980 wxGBSizerItem *arg2 = 0 ;
49981 bool result;
49982 void *argp1 = 0 ;
49983 int res1 = 0 ;
49984 void *argp2 = 0 ;
49985 int res2 = 0 ;
49986 PyObject * obj0 = 0 ;
49987 PyObject * obj1 = 0 ;
49988 char * kwnames[] = {
49989 (char *) "self",(char *) "other", NULL
49990 };
49991
49992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49994 if (!SWIG_IsOK(res1)) {
49995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49996 }
49997 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49998 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49999 if (!SWIG_IsOK(res2)) {
50000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50001 }
50002 if (!argp2) {
50003 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50004 }
50005 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50006 {
50007 PyThreadState* __tstate = wxPyBeginAllowThreads();
50008 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50009 wxPyEndAllowThreads(__tstate);
50010 if (PyErr_Occurred()) SWIG_fail;
50011 }
50012 {
50013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50014 }
50015 return resultobj;
50016 fail:
50017 return NULL;
50018 }
50019
50020
50021 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50022 PyObject *resultobj = 0;
50023 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50024 wxGBPosition *arg2 = 0 ;
50025 wxGBSpan *arg3 = 0 ;
50026 bool result;
50027 void *argp1 = 0 ;
50028 int res1 = 0 ;
50029 wxGBPosition temp2 ;
50030 wxGBSpan temp3 ;
50031 PyObject * obj0 = 0 ;
50032 PyObject * obj1 = 0 ;
50033 PyObject * obj2 = 0 ;
50034 char * kwnames[] = {
50035 (char *) "self",(char *) "pos",(char *) "span", NULL
50036 };
50037
50038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50040 if (!SWIG_IsOK(res1)) {
50041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50042 }
50043 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50044 {
50045 arg2 = &temp2;
50046 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50047 }
50048 {
50049 arg3 = &temp3;
50050 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50051 }
50052 {
50053 PyThreadState* __tstate = wxPyBeginAllowThreads();
50054 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50055 wxPyEndAllowThreads(__tstate);
50056 if (PyErr_Occurred()) SWIG_fail;
50057 }
50058 {
50059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50060 }
50061 return resultobj;
50062 fail:
50063 return NULL;
50064 }
50065
50066
50067 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50068 PyObject *resultobj = 0;
50069 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50070 wxGBPosition result;
50071 void *argp1 = 0 ;
50072 int res1 = 0 ;
50073 PyObject *swig_obj[1] ;
50074
50075 if (!args) SWIG_fail;
50076 swig_obj[0] = args;
50077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50078 if (!SWIG_IsOK(res1)) {
50079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50080 }
50081 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50082 {
50083 PyThreadState* __tstate = wxPyBeginAllowThreads();
50084 result = wxGBSizerItem_GetEndPos(arg1);
50085 wxPyEndAllowThreads(__tstate);
50086 if (PyErr_Occurred()) SWIG_fail;
50087 }
50088 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50089 return resultobj;
50090 fail:
50091 return NULL;
50092 }
50093
50094
50095 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50096 PyObject *resultobj = 0;
50097 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50098 wxGridBagSizer *result = 0 ;
50099 void *argp1 = 0 ;
50100 int res1 = 0 ;
50101 PyObject *swig_obj[1] ;
50102
50103 if (!args) SWIG_fail;
50104 swig_obj[0] = args;
50105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50106 if (!SWIG_IsOK(res1)) {
50107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50108 }
50109 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50110 {
50111 PyThreadState* __tstate = wxPyBeginAllowThreads();
50112 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50113 wxPyEndAllowThreads(__tstate);
50114 if (PyErr_Occurred()) SWIG_fail;
50115 }
50116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50117 return resultobj;
50118 fail:
50119 return NULL;
50120 }
50121
50122
50123 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50124 PyObject *resultobj = 0;
50125 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50126 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50127 void *argp1 = 0 ;
50128 int res1 = 0 ;
50129 void *argp2 = 0 ;
50130 int res2 = 0 ;
50131 PyObject * obj0 = 0 ;
50132 PyObject * obj1 = 0 ;
50133 char * kwnames[] = {
50134 (char *) "self",(char *) "sizer", NULL
50135 };
50136
50137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50139 if (!SWIG_IsOK(res1)) {
50140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50141 }
50142 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50143 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50144 if (!SWIG_IsOK(res2)) {
50145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50146 }
50147 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50148 {
50149 PyThreadState* __tstate = wxPyBeginAllowThreads();
50150 (arg1)->SetGBSizer(arg2);
50151 wxPyEndAllowThreads(__tstate);
50152 if (PyErr_Occurred()) SWIG_fail;
50153 }
50154 resultobj = SWIG_Py_Void();
50155 return resultobj;
50156 fail:
50157 return NULL;
50158 }
50159
50160
50161 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50162 PyObject *obj;
50163 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50164 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50165 return SWIG_Py_Void();
50166 }
50167
50168 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50169 return SWIG_Python_InitShadowInstance(args);
50170 }
50171
50172 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50173 PyObject *resultobj = 0;
50174 int arg1 = (int) 0 ;
50175 int arg2 = (int) 0 ;
50176 wxGridBagSizer *result = 0 ;
50177 int val1 ;
50178 int ecode1 = 0 ;
50179 int val2 ;
50180 int ecode2 = 0 ;
50181 PyObject * obj0 = 0 ;
50182 PyObject * obj1 = 0 ;
50183 char * kwnames[] = {
50184 (char *) "vgap",(char *) "hgap", NULL
50185 };
50186
50187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50188 if (obj0) {
50189 ecode1 = SWIG_AsVal_int(obj0, &val1);
50190 if (!SWIG_IsOK(ecode1)) {
50191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50192 }
50193 arg1 = static_cast< int >(val1);
50194 }
50195 if (obj1) {
50196 ecode2 = SWIG_AsVal_int(obj1, &val2);
50197 if (!SWIG_IsOK(ecode2)) {
50198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50199 }
50200 arg2 = static_cast< int >(val2);
50201 }
50202 {
50203 PyThreadState* __tstate = wxPyBeginAllowThreads();
50204 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50205 wxPyEndAllowThreads(__tstate);
50206 if (PyErr_Occurred()) SWIG_fail;
50207 }
50208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50209 return resultobj;
50210 fail:
50211 return NULL;
50212 }
50213
50214
50215 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50216 PyObject *resultobj = 0;
50217 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50218 PyObject *arg2 = (PyObject *) 0 ;
50219 wxGBPosition *arg3 = 0 ;
50220 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50221 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50222 int arg5 = (int) 0 ;
50223 int arg6 = (int) 0 ;
50224 PyObject *arg7 = (PyObject *) NULL ;
50225 wxGBSizerItem *result = 0 ;
50226 void *argp1 = 0 ;
50227 int res1 = 0 ;
50228 wxGBPosition temp3 ;
50229 wxGBSpan temp4 ;
50230 int val5 ;
50231 int ecode5 = 0 ;
50232 int val6 ;
50233 int ecode6 = 0 ;
50234 PyObject * obj0 = 0 ;
50235 PyObject * obj1 = 0 ;
50236 PyObject * obj2 = 0 ;
50237 PyObject * obj3 = 0 ;
50238 PyObject * obj4 = 0 ;
50239 PyObject * obj5 = 0 ;
50240 PyObject * obj6 = 0 ;
50241 char * kwnames[] = {
50242 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50243 };
50244
50245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50247 if (!SWIG_IsOK(res1)) {
50248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50249 }
50250 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50251 arg2 = obj1;
50252 {
50253 arg3 = &temp3;
50254 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50255 }
50256 if (obj3) {
50257 {
50258 arg4 = &temp4;
50259 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50260 }
50261 }
50262 if (obj4) {
50263 ecode5 = SWIG_AsVal_int(obj4, &val5);
50264 if (!SWIG_IsOK(ecode5)) {
50265 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50266 }
50267 arg5 = static_cast< int >(val5);
50268 }
50269 if (obj5) {
50270 ecode6 = SWIG_AsVal_int(obj5, &val6);
50271 if (!SWIG_IsOK(ecode6)) {
50272 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50273 }
50274 arg6 = static_cast< int >(val6);
50275 }
50276 if (obj6) {
50277 arg7 = obj6;
50278 }
50279 {
50280 PyThreadState* __tstate = wxPyBeginAllowThreads();
50281 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50282 wxPyEndAllowThreads(__tstate);
50283 if (PyErr_Occurred()) SWIG_fail;
50284 }
50285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50286 return resultobj;
50287 fail:
50288 return NULL;
50289 }
50290
50291
50292 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50293 PyObject *resultobj = 0;
50294 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50295 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50296 wxGBSizerItem *result = 0 ;
50297 void *argp1 = 0 ;
50298 int res1 = 0 ;
50299 int res2 = 0 ;
50300 PyObject * obj0 = 0 ;
50301 PyObject * obj1 = 0 ;
50302 char * kwnames[] = {
50303 (char *) "self",(char *) "item", NULL
50304 };
50305
50306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50308 if (!SWIG_IsOK(res1)) {
50309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50310 }
50311 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50312 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50313 if (!SWIG_IsOK(res2)) {
50314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50315 }
50316 {
50317 PyThreadState* __tstate = wxPyBeginAllowThreads();
50318 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50319 wxPyEndAllowThreads(__tstate);
50320 if (PyErr_Occurred()) SWIG_fail;
50321 }
50322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50323 return resultobj;
50324 fail:
50325 return NULL;
50326 }
50327
50328
50329 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50330 PyObject *resultobj = 0;
50331 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50332 int arg2 ;
50333 int arg3 ;
50334 wxSize result;
50335 void *argp1 = 0 ;
50336 int res1 = 0 ;
50337 int val2 ;
50338 int ecode2 = 0 ;
50339 int val3 ;
50340 int ecode3 = 0 ;
50341 PyObject * obj0 = 0 ;
50342 PyObject * obj1 = 0 ;
50343 PyObject * obj2 = 0 ;
50344 char * kwnames[] = {
50345 (char *) "self",(char *) "row",(char *) "col", NULL
50346 };
50347
50348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50350 if (!SWIG_IsOK(res1)) {
50351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50352 }
50353 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50354 ecode2 = SWIG_AsVal_int(obj1, &val2);
50355 if (!SWIG_IsOK(ecode2)) {
50356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50357 }
50358 arg2 = static_cast< int >(val2);
50359 ecode3 = SWIG_AsVal_int(obj2, &val3);
50360 if (!SWIG_IsOK(ecode3)) {
50361 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50362 }
50363 arg3 = static_cast< int >(val3);
50364 {
50365 PyThreadState* __tstate = wxPyBeginAllowThreads();
50366 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50367 wxPyEndAllowThreads(__tstate);
50368 if (PyErr_Occurred()) SWIG_fail;
50369 }
50370 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50371 return resultobj;
50372 fail:
50373 return NULL;
50374 }
50375
50376
50377 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50378 PyObject *resultobj = 0;
50379 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50380 wxSize result;
50381 void *argp1 = 0 ;
50382 int res1 = 0 ;
50383 PyObject *swig_obj[1] ;
50384
50385 if (!args) SWIG_fail;
50386 swig_obj[0] = args;
50387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50388 if (!SWIG_IsOK(res1)) {
50389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50390 }
50391 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50392 {
50393 PyThreadState* __tstate = wxPyBeginAllowThreads();
50394 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50395 wxPyEndAllowThreads(__tstate);
50396 if (PyErr_Occurred()) SWIG_fail;
50397 }
50398 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50399 return resultobj;
50400 fail:
50401 return NULL;
50402 }
50403
50404
50405 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50406 PyObject *resultobj = 0;
50407 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50408 wxSize *arg2 = 0 ;
50409 void *argp1 = 0 ;
50410 int res1 = 0 ;
50411 wxSize temp2 ;
50412 PyObject * obj0 = 0 ;
50413 PyObject * obj1 = 0 ;
50414 char * kwnames[] = {
50415 (char *) "self",(char *) "sz", NULL
50416 };
50417
50418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50420 if (!SWIG_IsOK(res1)) {
50421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50422 }
50423 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50424 {
50425 arg2 = &temp2;
50426 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50427 }
50428 {
50429 PyThreadState* __tstate = wxPyBeginAllowThreads();
50430 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50431 wxPyEndAllowThreads(__tstate);
50432 if (PyErr_Occurred()) SWIG_fail;
50433 }
50434 resultobj = SWIG_Py_Void();
50435 return resultobj;
50436 fail:
50437 return NULL;
50438 }
50439
50440
50441 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50442 PyObject *resultobj = 0;
50443 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50444 wxWindow *arg2 = (wxWindow *) 0 ;
50445 wxGBPosition result;
50446 void *argp1 = 0 ;
50447 int res1 = 0 ;
50448 void *argp2 = 0 ;
50449 int res2 = 0 ;
50450
50451 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50453 if (!SWIG_IsOK(res1)) {
50454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50455 }
50456 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50457 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50458 if (!SWIG_IsOK(res2)) {
50459 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50460 }
50461 arg2 = reinterpret_cast< wxWindow * >(argp2);
50462 {
50463 PyThreadState* __tstate = wxPyBeginAllowThreads();
50464 result = (arg1)->GetItemPosition(arg2);
50465 wxPyEndAllowThreads(__tstate);
50466 if (PyErr_Occurred()) SWIG_fail;
50467 }
50468 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50469 return resultobj;
50470 fail:
50471 return NULL;
50472 }
50473
50474
50475 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50476 PyObject *resultobj = 0;
50477 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50478 wxSizer *arg2 = (wxSizer *) 0 ;
50479 wxGBPosition result;
50480 void *argp1 = 0 ;
50481 int res1 = 0 ;
50482 void *argp2 = 0 ;
50483 int res2 = 0 ;
50484
50485 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50487 if (!SWIG_IsOK(res1)) {
50488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50489 }
50490 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50491 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50492 if (!SWIG_IsOK(res2)) {
50493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50494 }
50495 arg2 = reinterpret_cast< wxSizer * >(argp2);
50496 {
50497 PyThreadState* __tstate = wxPyBeginAllowThreads();
50498 result = (arg1)->GetItemPosition(arg2);
50499 wxPyEndAllowThreads(__tstate);
50500 if (PyErr_Occurred()) SWIG_fail;
50501 }
50502 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50503 return resultobj;
50504 fail:
50505 return NULL;
50506 }
50507
50508
50509 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50510 PyObject *resultobj = 0;
50511 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50512 size_t arg2 ;
50513 wxGBPosition result;
50514 void *argp1 = 0 ;
50515 int res1 = 0 ;
50516 size_t val2 ;
50517 int ecode2 = 0 ;
50518
50519 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50521 if (!SWIG_IsOK(res1)) {
50522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50523 }
50524 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50525 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50526 if (!SWIG_IsOK(ecode2)) {
50527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50528 }
50529 arg2 = static_cast< size_t >(val2);
50530 {
50531 PyThreadState* __tstate = wxPyBeginAllowThreads();
50532 result = (arg1)->GetItemPosition(arg2);
50533 wxPyEndAllowThreads(__tstate);
50534 if (PyErr_Occurred()) SWIG_fail;
50535 }
50536 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50537 return resultobj;
50538 fail:
50539 return NULL;
50540 }
50541
50542
50543 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50544 int argc;
50545 PyObject *argv[3];
50546
50547 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50548 --argc;
50549 if (argc == 2) {
50550 int _v = 0;
50551 {
50552 void *vptr = 0;
50553 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50554 _v = SWIG_CheckState(res);
50555 }
50556 if (!_v) goto check_1;
50557 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50558 }
50559 check_1:
50560
50561 if (argc == 2) {
50562 int _v = 0;
50563 {
50564 void *vptr = 0;
50565 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50566 _v = SWIG_CheckState(res);
50567 }
50568 if (!_v) goto check_2;
50569 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50570 }
50571 check_2:
50572
50573 if (argc == 2) {
50574 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50575 }
50576
50577 fail:
50578 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50579 return NULL;
50580 }
50581
50582
50583 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50584 PyObject *resultobj = 0;
50585 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50586 wxWindow *arg2 = (wxWindow *) 0 ;
50587 wxGBPosition *arg3 = 0 ;
50588 bool result;
50589 void *argp1 = 0 ;
50590 int res1 = 0 ;
50591 void *argp2 = 0 ;
50592 int res2 = 0 ;
50593 wxGBPosition temp3 ;
50594
50595 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50597 if (!SWIG_IsOK(res1)) {
50598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50599 }
50600 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50601 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50602 if (!SWIG_IsOK(res2)) {
50603 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50604 }
50605 arg2 = reinterpret_cast< wxWindow * >(argp2);
50606 {
50607 arg3 = &temp3;
50608 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50609 }
50610 {
50611 PyThreadState* __tstate = wxPyBeginAllowThreads();
50612 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50613 wxPyEndAllowThreads(__tstate);
50614 if (PyErr_Occurred()) SWIG_fail;
50615 }
50616 {
50617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50618 }
50619 return resultobj;
50620 fail:
50621 return NULL;
50622 }
50623
50624
50625 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50626 PyObject *resultobj = 0;
50627 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50628 wxSizer *arg2 = (wxSizer *) 0 ;
50629 wxGBPosition *arg3 = 0 ;
50630 bool result;
50631 void *argp1 = 0 ;
50632 int res1 = 0 ;
50633 void *argp2 = 0 ;
50634 int res2 = 0 ;
50635 wxGBPosition temp3 ;
50636
50637 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50639 if (!SWIG_IsOK(res1)) {
50640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50641 }
50642 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50643 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50644 if (!SWIG_IsOK(res2)) {
50645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50646 }
50647 arg2 = reinterpret_cast< wxSizer * >(argp2);
50648 {
50649 arg3 = &temp3;
50650 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50651 }
50652 {
50653 PyThreadState* __tstate = wxPyBeginAllowThreads();
50654 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50655 wxPyEndAllowThreads(__tstate);
50656 if (PyErr_Occurred()) SWIG_fail;
50657 }
50658 {
50659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50660 }
50661 return resultobj;
50662 fail:
50663 return NULL;
50664 }
50665
50666
50667 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50668 PyObject *resultobj = 0;
50669 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50670 size_t arg2 ;
50671 wxGBPosition *arg3 = 0 ;
50672 bool result;
50673 void *argp1 = 0 ;
50674 int res1 = 0 ;
50675 size_t val2 ;
50676 int ecode2 = 0 ;
50677 wxGBPosition temp3 ;
50678
50679 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50681 if (!SWIG_IsOK(res1)) {
50682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50683 }
50684 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50685 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50686 if (!SWIG_IsOK(ecode2)) {
50687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50688 }
50689 arg2 = static_cast< size_t >(val2);
50690 {
50691 arg3 = &temp3;
50692 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50693 }
50694 {
50695 PyThreadState* __tstate = wxPyBeginAllowThreads();
50696 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50697 wxPyEndAllowThreads(__tstate);
50698 if (PyErr_Occurred()) SWIG_fail;
50699 }
50700 {
50701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50702 }
50703 return resultobj;
50704 fail:
50705 return NULL;
50706 }
50707
50708
50709 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50710 int argc;
50711 PyObject *argv[4];
50712
50713 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50714 --argc;
50715 if (argc == 3) {
50716 int _v = 0;
50717 {
50718 void *vptr = 0;
50719 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50720 _v = SWIG_CheckState(res);
50721 }
50722 if (!_v) goto check_1;
50723 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50724 }
50725 check_1:
50726
50727 if (argc == 3) {
50728 int _v = 0;
50729 {
50730 void *vptr = 0;
50731 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50732 _v = SWIG_CheckState(res);
50733 }
50734 if (!_v) goto check_2;
50735 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50736 }
50737 check_2:
50738
50739 if (argc == 3) {
50740 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50741 }
50742
50743 fail:
50744 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50745 return NULL;
50746 }
50747
50748
50749 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50750 PyObject *resultobj = 0;
50751 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50752 wxWindow *arg2 = (wxWindow *) 0 ;
50753 wxGBSpan result;
50754 void *argp1 = 0 ;
50755 int res1 = 0 ;
50756 void *argp2 = 0 ;
50757 int res2 = 0 ;
50758
50759 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50761 if (!SWIG_IsOK(res1)) {
50762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50763 }
50764 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50765 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50766 if (!SWIG_IsOK(res2)) {
50767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50768 }
50769 arg2 = reinterpret_cast< wxWindow * >(argp2);
50770 {
50771 PyThreadState* __tstate = wxPyBeginAllowThreads();
50772 result = (arg1)->GetItemSpan(arg2);
50773 wxPyEndAllowThreads(__tstate);
50774 if (PyErr_Occurred()) SWIG_fail;
50775 }
50776 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50777 return resultobj;
50778 fail:
50779 return NULL;
50780 }
50781
50782
50783 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50784 PyObject *resultobj = 0;
50785 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50786 wxSizer *arg2 = (wxSizer *) 0 ;
50787 wxGBSpan result;
50788 void *argp1 = 0 ;
50789 int res1 = 0 ;
50790 void *argp2 = 0 ;
50791 int res2 = 0 ;
50792
50793 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50795 if (!SWIG_IsOK(res1)) {
50796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50797 }
50798 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50799 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50800 if (!SWIG_IsOK(res2)) {
50801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50802 }
50803 arg2 = reinterpret_cast< wxSizer * >(argp2);
50804 {
50805 PyThreadState* __tstate = wxPyBeginAllowThreads();
50806 result = (arg1)->GetItemSpan(arg2);
50807 wxPyEndAllowThreads(__tstate);
50808 if (PyErr_Occurred()) SWIG_fail;
50809 }
50810 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50811 return resultobj;
50812 fail:
50813 return NULL;
50814 }
50815
50816
50817 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50818 PyObject *resultobj = 0;
50819 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50820 size_t arg2 ;
50821 wxGBSpan result;
50822 void *argp1 = 0 ;
50823 int res1 = 0 ;
50824 size_t val2 ;
50825 int ecode2 = 0 ;
50826
50827 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50829 if (!SWIG_IsOK(res1)) {
50830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50831 }
50832 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50833 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50834 if (!SWIG_IsOK(ecode2)) {
50835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50836 }
50837 arg2 = static_cast< size_t >(val2);
50838 {
50839 PyThreadState* __tstate = wxPyBeginAllowThreads();
50840 result = (arg1)->GetItemSpan(arg2);
50841 wxPyEndAllowThreads(__tstate);
50842 if (PyErr_Occurred()) SWIG_fail;
50843 }
50844 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50845 return resultobj;
50846 fail:
50847 return NULL;
50848 }
50849
50850
50851 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50852 int argc;
50853 PyObject *argv[3];
50854
50855 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50856 --argc;
50857 if (argc == 2) {
50858 int _v = 0;
50859 {
50860 void *vptr = 0;
50861 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50862 _v = SWIG_CheckState(res);
50863 }
50864 if (!_v) goto check_1;
50865 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50866 }
50867 check_1:
50868
50869 if (argc == 2) {
50870 int _v = 0;
50871 {
50872 void *vptr = 0;
50873 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50874 _v = SWIG_CheckState(res);
50875 }
50876 if (!_v) goto check_2;
50877 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50878 }
50879 check_2:
50880
50881 if (argc == 2) {
50882 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50883 }
50884
50885 fail:
50886 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50887 return NULL;
50888 }
50889
50890
50891 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50892 PyObject *resultobj = 0;
50893 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50894 wxWindow *arg2 = (wxWindow *) 0 ;
50895 wxGBSpan *arg3 = 0 ;
50896 bool result;
50897 void *argp1 = 0 ;
50898 int res1 = 0 ;
50899 void *argp2 = 0 ;
50900 int res2 = 0 ;
50901 wxGBSpan temp3 ;
50902
50903 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50905 if (!SWIG_IsOK(res1)) {
50906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50907 }
50908 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50909 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50910 if (!SWIG_IsOK(res2)) {
50911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50912 }
50913 arg2 = reinterpret_cast< wxWindow * >(argp2);
50914 {
50915 arg3 = &temp3;
50916 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50917 }
50918 {
50919 PyThreadState* __tstate = wxPyBeginAllowThreads();
50920 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50921 wxPyEndAllowThreads(__tstate);
50922 if (PyErr_Occurred()) SWIG_fail;
50923 }
50924 {
50925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50926 }
50927 return resultobj;
50928 fail:
50929 return NULL;
50930 }
50931
50932
50933 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50934 PyObject *resultobj = 0;
50935 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50936 wxSizer *arg2 = (wxSizer *) 0 ;
50937 wxGBSpan *arg3 = 0 ;
50938 bool result;
50939 void *argp1 = 0 ;
50940 int res1 = 0 ;
50941 void *argp2 = 0 ;
50942 int res2 = 0 ;
50943 wxGBSpan temp3 ;
50944
50945 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50947 if (!SWIG_IsOK(res1)) {
50948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50949 }
50950 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50951 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50952 if (!SWIG_IsOK(res2)) {
50953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50954 }
50955 arg2 = reinterpret_cast< wxSizer * >(argp2);
50956 {
50957 arg3 = &temp3;
50958 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50959 }
50960 {
50961 PyThreadState* __tstate = wxPyBeginAllowThreads();
50962 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50963 wxPyEndAllowThreads(__tstate);
50964 if (PyErr_Occurred()) SWIG_fail;
50965 }
50966 {
50967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50968 }
50969 return resultobj;
50970 fail:
50971 return NULL;
50972 }
50973
50974
50975 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50976 PyObject *resultobj = 0;
50977 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50978 size_t arg2 ;
50979 wxGBSpan *arg3 = 0 ;
50980 bool result;
50981 void *argp1 = 0 ;
50982 int res1 = 0 ;
50983 size_t val2 ;
50984 int ecode2 = 0 ;
50985 wxGBSpan temp3 ;
50986
50987 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50989 if (!SWIG_IsOK(res1)) {
50990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50991 }
50992 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50993 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50994 if (!SWIG_IsOK(ecode2)) {
50995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50996 }
50997 arg2 = static_cast< size_t >(val2);
50998 {
50999 arg3 = &temp3;
51000 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51001 }
51002 {
51003 PyThreadState* __tstate = wxPyBeginAllowThreads();
51004 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51005 wxPyEndAllowThreads(__tstate);
51006 if (PyErr_Occurred()) SWIG_fail;
51007 }
51008 {
51009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51010 }
51011 return resultobj;
51012 fail:
51013 return NULL;
51014 }
51015
51016
51017 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51018 int argc;
51019 PyObject *argv[4];
51020
51021 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51022 --argc;
51023 if (argc == 3) {
51024 int _v = 0;
51025 {
51026 void *vptr = 0;
51027 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51028 _v = SWIG_CheckState(res);
51029 }
51030 if (!_v) goto check_1;
51031 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51032 }
51033 check_1:
51034
51035 if (argc == 3) {
51036 int _v = 0;
51037 {
51038 void *vptr = 0;
51039 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51040 _v = SWIG_CheckState(res);
51041 }
51042 if (!_v) goto check_2;
51043 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51044 }
51045 check_2:
51046
51047 if (argc == 3) {
51048 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51049 }
51050
51051 fail:
51052 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51053 return NULL;
51054 }
51055
51056
51057 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51058 PyObject *resultobj = 0;
51059 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51060 wxWindow *arg2 = (wxWindow *) 0 ;
51061 wxGBSizerItem *result = 0 ;
51062 void *argp1 = 0 ;
51063 int res1 = 0 ;
51064 void *argp2 = 0 ;
51065 int res2 = 0 ;
51066
51067 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51069 if (!SWIG_IsOK(res1)) {
51070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51071 }
51072 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51073 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51074 if (!SWIG_IsOK(res2)) {
51075 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51076 }
51077 arg2 = reinterpret_cast< wxWindow * >(argp2);
51078 {
51079 PyThreadState* __tstate = wxPyBeginAllowThreads();
51080 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51081 wxPyEndAllowThreads(__tstate);
51082 if (PyErr_Occurred()) SWIG_fail;
51083 }
51084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51085 return resultobj;
51086 fail:
51087 return NULL;
51088 }
51089
51090
51091 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51092 PyObject *resultobj = 0;
51093 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51094 wxSizer *arg2 = (wxSizer *) 0 ;
51095 wxGBSizerItem *result = 0 ;
51096 void *argp1 = 0 ;
51097 int res1 = 0 ;
51098 void *argp2 = 0 ;
51099 int res2 = 0 ;
51100
51101 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51103 if (!SWIG_IsOK(res1)) {
51104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51105 }
51106 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51107 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51108 if (!SWIG_IsOK(res2)) {
51109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51110 }
51111 arg2 = reinterpret_cast< wxSizer * >(argp2);
51112 {
51113 PyThreadState* __tstate = wxPyBeginAllowThreads();
51114 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51115 wxPyEndAllowThreads(__tstate);
51116 if (PyErr_Occurred()) SWIG_fail;
51117 }
51118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51119 return resultobj;
51120 fail:
51121 return NULL;
51122 }
51123
51124
51125 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51126 int argc;
51127 PyObject *argv[3];
51128
51129 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51130 --argc;
51131 if (argc == 2) {
51132 int _v = 0;
51133 {
51134 void *vptr = 0;
51135 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51136 _v = SWIG_CheckState(res);
51137 }
51138 if (!_v) goto check_1;
51139 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51140 }
51141 check_1:
51142
51143 if (argc == 2) {
51144 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51145 }
51146
51147 fail:
51148 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51149 return NULL;
51150 }
51151
51152
51153 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51154 PyObject *resultobj = 0;
51155 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51156 wxGBPosition *arg2 = 0 ;
51157 wxGBSizerItem *result = 0 ;
51158 void *argp1 = 0 ;
51159 int res1 = 0 ;
51160 wxGBPosition temp2 ;
51161 PyObject * obj0 = 0 ;
51162 PyObject * obj1 = 0 ;
51163 char * kwnames[] = {
51164 (char *) "self",(char *) "pos", NULL
51165 };
51166
51167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51169 if (!SWIG_IsOK(res1)) {
51170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51171 }
51172 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51173 {
51174 arg2 = &temp2;
51175 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51176 }
51177 {
51178 PyThreadState* __tstate = wxPyBeginAllowThreads();
51179 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51180 wxPyEndAllowThreads(__tstate);
51181 if (PyErr_Occurred()) SWIG_fail;
51182 }
51183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51184 return resultobj;
51185 fail:
51186 return NULL;
51187 }
51188
51189
51190 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51191 PyObject *resultobj = 0;
51192 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51193 wxPoint *arg2 = 0 ;
51194 wxGBSizerItem *result = 0 ;
51195 void *argp1 = 0 ;
51196 int res1 = 0 ;
51197 wxPoint temp2 ;
51198 PyObject * obj0 = 0 ;
51199 PyObject * obj1 = 0 ;
51200 char * kwnames[] = {
51201 (char *) "self",(char *) "pt", NULL
51202 };
51203
51204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51206 if (!SWIG_IsOK(res1)) {
51207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51208 }
51209 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51210 {
51211 arg2 = &temp2;
51212 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51213 }
51214 {
51215 PyThreadState* __tstate = wxPyBeginAllowThreads();
51216 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51217 wxPyEndAllowThreads(__tstate);
51218 if (PyErr_Occurred()) SWIG_fail;
51219 }
51220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51221 return resultobj;
51222 fail:
51223 return NULL;
51224 }
51225
51226
51227 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51228 PyObject *resultobj = 0;
51229 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51230 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51231 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51232 bool result;
51233 void *argp1 = 0 ;
51234 int res1 = 0 ;
51235 void *argp2 = 0 ;
51236 int res2 = 0 ;
51237 void *argp3 = 0 ;
51238 int res3 = 0 ;
51239 PyObject * obj0 = 0 ;
51240 PyObject * obj1 = 0 ;
51241 PyObject * obj2 = 0 ;
51242 char * kwnames[] = {
51243 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51244 };
51245
51246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51248 if (!SWIG_IsOK(res1)) {
51249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51250 }
51251 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51252 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51253 if (!SWIG_IsOK(res2)) {
51254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51255 }
51256 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51257 if (obj2) {
51258 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51259 if (!SWIG_IsOK(res3)) {
51260 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51261 }
51262 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51263 }
51264 {
51265 PyThreadState* __tstate = wxPyBeginAllowThreads();
51266 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51267 wxPyEndAllowThreads(__tstate);
51268 if (PyErr_Occurred()) SWIG_fail;
51269 }
51270 {
51271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51272 }
51273 return resultobj;
51274 fail:
51275 return NULL;
51276 }
51277
51278
51279 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51280 PyObject *resultobj = 0;
51281 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51282 wxGBPosition *arg2 = 0 ;
51283 wxGBSpan *arg3 = 0 ;
51284 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51285 bool result;
51286 void *argp1 = 0 ;
51287 int res1 = 0 ;
51288 wxGBPosition temp2 ;
51289 wxGBSpan temp3 ;
51290 void *argp4 = 0 ;
51291 int res4 = 0 ;
51292 PyObject * obj0 = 0 ;
51293 PyObject * obj1 = 0 ;
51294 PyObject * obj2 = 0 ;
51295 PyObject * obj3 = 0 ;
51296 char * kwnames[] = {
51297 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51298 };
51299
51300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51302 if (!SWIG_IsOK(res1)) {
51303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51304 }
51305 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51306 {
51307 arg2 = &temp2;
51308 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51309 }
51310 {
51311 arg3 = &temp3;
51312 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51313 }
51314 if (obj3) {
51315 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51316 if (!SWIG_IsOK(res4)) {
51317 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51318 }
51319 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51320 }
51321 {
51322 PyThreadState* __tstate = wxPyBeginAllowThreads();
51323 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51324 wxPyEndAllowThreads(__tstate);
51325 if (PyErr_Occurred()) SWIG_fail;
51326 }
51327 {
51328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51329 }
51330 return resultobj;
51331 fail:
51332 return NULL;
51333 }
51334
51335
51336 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51337 PyObject *obj;
51338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51339 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51340 return SWIG_Py_Void();
51341 }
51342
51343 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51344 return SWIG_Python_InitShadowInstance(args);
51345 }
51346
51347 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51348 PyObject *resultobj = 0;
51349 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51350 wxRelationship arg2 ;
51351 wxWindow *arg3 = (wxWindow *) 0 ;
51352 wxEdge arg4 ;
51353 int arg5 = (int) 0 ;
51354 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51355 void *argp1 = 0 ;
51356 int res1 = 0 ;
51357 int val2 ;
51358 int ecode2 = 0 ;
51359 void *argp3 = 0 ;
51360 int res3 = 0 ;
51361 int val4 ;
51362 int ecode4 = 0 ;
51363 int val5 ;
51364 int ecode5 = 0 ;
51365 int val6 ;
51366 int ecode6 = 0 ;
51367 PyObject * obj0 = 0 ;
51368 PyObject * obj1 = 0 ;
51369 PyObject * obj2 = 0 ;
51370 PyObject * obj3 = 0 ;
51371 PyObject * obj4 = 0 ;
51372 PyObject * obj5 = 0 ;
51373 char * kwnames[] = {
51374 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51375 };
51376
51377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51379 if (!SWIG_IsOK(res1)) {
51380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51381 }
51382 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51383 ecode2 = SWIG_AsVal_int(obj1, &val2);
51384 if (!SWIG_IsOK(ecode2)) {
51385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51386 }
51387 arg2 = static_cast< wxRelationship >(val2);
51388 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51389 if (!SWIG_IsOK(res3)) {
51390 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51391 }
51392 arg3 = reinterpret_cast< wxWindow * >(argp3);
51393 ecode4 = SWIG_AsVal_int(obj3, &val4);
51394 if (!SWIG_IsOK(ecode4)) {
51395 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51396 }
51397 arg4 = static_cast< wxEdge >(val4);
51398 if (obj4) {
51399 ecode5 = SWIG_AsVal_int(obj4, &val5);
51400 if (!SWIG_IsOK(ecode5)) {
51401 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51402 }
51403 arg5 = static_cast< int >(val5);
51404 }
51405 if (obj5) {
51406 ecode6 = SWIG_AsVal_int(obj5, &val6);
51407 if (!SWIG_IsOK(ecode6)) {
51408 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51409 }
51410 arg6 = static_cast< int >(val6);
51411 }
51412 {
51413 PyThreadState* __tstate = wxPyBeginAllowThreads();
51414 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51415 wxPyEndAllowThreads(__tstate);
51416 if (PyErr_Occurred()) SWIG_fail;
51417 }
51418 resultobj = SWIG_Py_Void();
51419 return resultobj;
51420 fail:
51421 return NULL;
51422 }
51423
51424
51425 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51426 PyObject *resultobj = 0;
51427 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51428 wxWindow *arg2 = (wxWindow *) 0 ;
51429 int arg3 = (int) 0 ;
51430 void *argp1 = 0 ;
51431 int res1 = 0 ;
51432 void *argp2 = 0 ;
51433 int res2 = 0 ;
51434 int val3 ;
51435 int ecode3 = 0 ;
51436 PyObject * obj0 = 0 ;
51437 PyObject * obj1 = 0 ;
51438 PyObject * obj2 = 0 ;
51439 char * kwnames[] = {
51440 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51441 };
51442
51443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51445 if (!SWIG_IsOK(res1)) {
51446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51447 }
51448 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51449 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51450 if (!SWIG_IsOK(res2)) {
51451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51452 }
51453 arg2 = reinterpret_cast< wxWindow * >(argp2);
51454 if (obj2) {
51455 ecode3 = SWIG_AsVal_int(obj2, &val3);
51456 if (!SWIG_IsOK(ecode3)) {
51457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51458 }
51459 arg3 = static_cast< int >(val3);
51460 }
51461 {
51462 PyThreadState* __tstate = wxPyBeginAllowThreads();
51463 (arg1)->LeftOf(arg2,arg3);
51464 wxPyEndAllowThreads(__tstate);
51465 if (PyErr_Occurred()) SWIG_fail;
51466 }
51467 resultobj = SWIG_Py_Void();
51468 return resultobj;
51469 fail:
51470 return NULL;
51471 }
51472
51473
51474 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51475 PyObject *resultobj = 0;
51476 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51477 wxWindow *arg2 = (wxWindow *) 0 ;
51478 int arg3 = (int) 0 ;
51479 void *argp1 = 0 ;
51480 int res1 = 0 ;
51481 void *argp2 = 0 ;
51482 int res2 = 0 ;
51483 int val3 ;
51484 int ecode3 = 0 ;
51485 PyObject * obj0 = 0 ;
51486 PyObject * obj1 = 0 ;
51487 PyObject * obj2 = 0 ;
51488 char * kwnames[] = {
51489 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51490 };
51491
51492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51494 if (!SWIG_IsOK(res1)) {
51495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51496 }
51497 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51498 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51499 if (!SWIG_IsOK(res2)) {
51500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51501 }
51502 arg2 = reinterpret_cast< wxWindow * >(argp2);
51503 if (obj2) {
51504 ecode3 = SWIG_AsVal_int(obj2, &val3);
51505 if (!SWIG_IsOK(ecode3)) {
51506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51507 }
51508 arg3 = static_cast< int >(val3);
51509 }
51510 {
51511 PyThreadState* __tstate = wxPyBeginAllowThreads();
51512 (arg1)->RightOf(arg2,arg3);
51513 wxPyEndAllowThreads(__tstate);
51514 if (PyErr_Occurred()) SWIG_fail;
51515 }
51516 resultobj = SWIG_Py_Void();
51517 return resultobj;
51518 fail:
51519 return NULL;
51520 }
51521
51522
51523 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51524 PyObject *resultobj = 0;
51525 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51526 wxWindow *arg2 = (wxWindow *) 0 ;
51527 int arg3 = (int) 0 ;
51528 void *argp1 = 0 ;
51529 int res1 = 0 ;
51530 void *argp2 = 0 ;
51531 int res2 = 0 ;
51532 int val3 ;
51533 int ecode3 = 0 ;
51534 PyObject * obj0 = 0 ;
51535 PyObject * obj1 = 0 ;
51536 PyObject * obj2 = 0 ;
51537 char * kwnames[] = {
51538 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51539 };
51540
51541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51543 if (!SWIG_IsOK(res1)) {
51544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51545 }
51546 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51547 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51548 if (!SWIG_IsOK(res2)) {
51549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51550 }
51551 arg2 = reinterpret_cast< wxWindow * >(argp2);
51552 if (obj2) {
51553 ecode3 = SWIG_AsVal_int(obj2, &val3);
51554 if (!SWIG_IsOK(ecode3)) {
51555 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51556 }
51557 arg3 = static_cast< int >(val3);
51558 }
51559 {
51560 PyThreadState* __tstate = wxPyBeginAllowThreads();
51561 (arg1)->Above(arg2,arg3);
51562 wxPyEndAllowThreads(__tstate);
51563 if (PyErr_Occurred()) SWIG_fail;
51564 }
51565 resultobj = SWIG_Py_Void();
51566 return resultobj;
51567 fail:
51568 return NULL;
51569 }
51570
51571
51572 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51573 PyObject *resultobj = 0;
51574 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51575 wxWindow *arg2 = (wxWindow *) 0 ;
51576 int arg3 = (int) 0 ;
51577 void *argp1 = 0 ;
51578 int res1 = 0 ;
51579 void *argp2 = 0 ;
51580 int res2 = 0 ;
51581 int val3 ;
51582 int ecode3 = 0 ;
51583 PyObject * obj0 = 0 ;
51584 PyObject * obj1 = 0 ;
51585 PyObject * obj2 = 0 ;
51586 char * kwnames[] = {
51587 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51588 };
51589
51590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51592 if (!SWIG_IsOK(res1)) {
51593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51594 }
51595 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51596 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51597 if (!SWIG_IsOK(res2)) {
51598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51599 }
51600 arg2 = reinterpret_cast< wxWindow * >(argp2);
51601 if (obj2) {
51602 ecode3 = SWIG_AsVal_int(obj2, &val3);
51603 if (!SWIG_IsOK(ecode3)) {
51604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51605 }
51606 arg3 = static_cast< int >(val3);
51607 }
51608 {
51609 PyThreadState* __tstate = wxPyBeginAllowThreads();
51610 (arg1)->Below(arg2,arg3);
51611 wxPyEndAllowThreads(__tstate);
51612 if (PyErr_Occurred()) SWIG_fail;
51613 }
51614 resultobj = SWIG_Py_Void();
51615 return resultobj;
51616 fail:
51617 return NULL;
51618 }
51619
51620
51621 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51622 PyObject *resultobj = 0;
51623 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51624 wxWindow *arg2 = (wxWindow *) 0 ;
51625 wxEdge arg3 ;
51626 int arg4 = (int) 0 ;
51627 void *argp1 = 0 ;
51628 int res1 = 0 ;
51629 void *argp2 = 0 ;
51630 int res2 = 0 ;
51631 int val3 ;
51632 int ecode3 = 0 ;
51633 int val4 ;
51634 int ecode4 = 0 ;
51635 PyObject * obj0 = 0 ;
51636 PyObject * obj1 = 0 ;
51637 PyObject * obj2 = 0 ;
51638 PyObject * obj3 = 0 ;
51639 char * kwnames[] = {
51640 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51641 };
51642
51643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51645 if (!SWIG_IsOK(res1)) {
51646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51647 }
51648 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51649 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51650 if (!SWIG_IsOK(res2)) {
51651 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51652 }
51653 arg2 = reinterpret_cast< wxWindow * >(argp2);
51654 ecode3 = SWIG_AsVal_int(obj2, &val3);
51655 if (!SWIG_IsOK(ecode3)) {
51656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51657 }
51658 arg3 = static_cast< wxEdge >(val3);
51659 if (obj3) {
51660 ecode4 = SWIG_AsVal_int(obj3, &val4);
51661 if (!SWIG_IsOK(ecode4)) {
51662 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51663 }
51664 arg4 = static_cast< int >(val4);
51665 }
51666 {
51667 PyThreadState* __tstate = wxPyBeginAllowThreads();
51668 (arg1)->SameAs(arg2,arg3,arg4);
51669 wxPyEndAllowThreads(__tstate);
51670 if (PyErr_Occurred()) SWIG_fail;
51671 }
51672 resultobj = SWIG_Py_Void();
51673 return resultobj;
51674 fail:
51675 return NULL;
51676 }
51677
51678
51679 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51680 PyObject *resultobj = 0;
51681 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51682 wxWindow *arg2 = (wxWindow *) 0 ;
51683 wxEdge arg3 ;
51684 int arg4 ;
51685 void *argp1 = 0 ;
51686 int res1 = 0 ;
51687 void *argp2 = 0 ;
51688 int res2 = 0 ;
51689 int val3 ;
51690 int ecode3 = 0 ;
51691 int val4 ;
51692 int ecode4 = 0 ;
51693 PyObject * obj0 = 0 ;
51694 PyObject * obj1 = 0 ;
51695 PyObject * obj2 = 0 ;
51696 PyObject * obj3 = 0 ;
51697 char * kwnames[] = {
51698 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51699 };
51700
51701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51703 if (!SWIG_IsOK(res1)) {
51704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51705 }
51706 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51707 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51708 if (!SWIG_IsOK(res2)) {
51709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51710 }
51711 arg2 = reinterpret_cast< wxWindow * >(argp2);
51712 ecode3 = SWIG_AsVal_int(obj2, &val3);
51713 if (!SWIG_IsOK(ecode3)) {
51714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51715 }
51716 arg3 = static_cast< wxEdge >(val3);
51717 ecode4 = SWIG_AsVal_int(obj3, &val4);
51718 if (!SWIG_IsOK(ecode4)) {
51719 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51720 }
51721 arg4 = static_cast< int >(val4);
51722 {
51723 PyThreadState* __tstate = wxPyBeginAllowThreads();
51724 (arg1)->PercentOf(arg2,arg3,arg4);
51725 wxPyEndAllowThreads(__tstate);
51726 if (PyErr_Occurred()) SWIG_fail;
51727 }
51728 resultobj = SWIG_Py_Void();
51729 return resultobj;
51730 fail:
51731 return NULL;
51732 }
51733
51734
51735 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51736 PyObject *resultobj = 0;
51737 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51738 int arg2 ;
51739 void *argp1 = 0 ;
51740 int res1 = 0 ;
51741 int val2 ;
51742 int ecode2 = 0 ;
51743 PyObject * obj0 = 0 ;
51744 PyObject * obj1 = 0 ;
51745 char * kwnames[] = {
51746 (char *) "self",(char *) "val", NULL
51747 };
51748
51749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51751 if (!SWIG_IsOK(res1)) {
51752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51753 }
51754 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51755 ecode2 = SWIG_AsVal_int(obj1, &val2);
51756 if (!SWIG_IsOK(ecode2)) {
51757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51758 }
51759 arg2 = static_cast< int >(val2);
51760 {
51761 PyThreadState* __tstate = wxPyBeginAllowThreads();
51762 (arg1)->Absolute(arg2);
51763 wxPyEndAllowThreads(__tstate);
51764 if (PyErr_Occurred()) SWIG_fail;
51765 }
51766 resultobj = SWIG_Py_Void();
51767 return resultobj;
51768 fail:
51769 return NULL;
51770 }
51771
51772
51773 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51774 PyObject *resultobj = 0;
51775 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51776 void *argp1 = 0 ;
51777 int res1 = 0 ;
51778 PyObject *swig_obj[1] ;
51779
51780 if (!args) SWIG_fail;
51781 swig_obj[0] = args;
51782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51783 if (!SWIG_IsOK(res1)) {
51784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51785 }
51786 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51787 {
51788 PyThreadState* __tstate = wxPyBeginAllowThreads();
51789 (arg1)->Unconstrained();
51790 wxPyEndAllowThreads(__tstate);
51791 if (PyErr_Occurred()) SWIG_fail;
51792 }
51793 resultobj = SWIG_Py_Void();
51794 return resultobj;
51795 fail:
51796 return NULL;
51797 }
51798
51799
51800 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51801 PyObject *resultobj = 0;
51802 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51803 void *argp1 = 0 ;
51804 int res1 = 0 ;
51805 PyObject *swig_obj[1] ;
51806
51807 if (!args) SWIG_fail;
51808 swig_obj[0] = args;
51809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51810 if (!SWIG_IsOK(res1)) {
51811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51812 }
51813 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51814 {
51815 PyThreadState* __tstate = wxPyBeginAllowThreads();
51816 (arg1)->AsIs();
51817 wxPyEndAllowThreads(__tstate);
51818 if (PyErr_Occurred()) SWIG_fail;
51819 }
51820 resultobj = SWIG_Py_Void();
51821 return resultobj;
51822 fail:
51823 return NULL;
51824 }
51825
51826
51827 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51828 PyObject *resultobj = 0;
51829 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51830 wxWindow *result = 0 ;
51831 void *argp1 = 0 ;
51832 int res1 = 0 ;
51833 PyObject *swig_obj[1] ;
51834
51835 if (!args) SWIG_fail;
51836 swig_obj[0] = args;
51837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51838 if (!SWIG_IsOK(res1)) {
51839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51840 }
51841 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51842 {
51843 PyThreadState* __tstate = wxPyBeginAllowThreads();
51844 result = (wxWindow *)(arg1)->GetOtherWindow();
51845 wxPyEndAllowThreads(__tstate);
51846 if (PyErr_Occurred()) SWIG_fail;
51847 }
51848 {
51849 resultobj = wxPyMake_wxObject(result, 0);
51850 }
51851 return resultobj;
51852 fail:
51853 return NULL;
51854 }
51855
51856
51857 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51858 PyObject *resultobj = 0;
51859 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51860 wxEdge result;
51861 void *argp1 = 0 ;
51862 int res1 = 0 ;
51863 PyObject *swig_obj[1] ;
51864
51865 if (!args) SWIG_fail;
51866 swig_obj[0] = args;
51867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51868 if (!SWIG_IsOK(res1)) {
51869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51870 }
51871 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51872 {
51873 PyThreadState* __tstate = wxPyBeginAllowThreads();
51874 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51875 wxPyEndAllowThreads(__tstate);
51876 if (PyErr_Occurred()) SWIG_fail;
51877 }
51878 resultobj = SWIG_From_int(static_cast< int >(result));
51879 return resultobj;
51880 fail:
51881 return NULL;
51882 }
51883
51884
51885 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51886 PyObject *resultobj = 0;
51887 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51888 wxEdge arg2 ;
51889 void *argp1 = 0 ;
51890 int res1 = 0 ;
51891 int val2 ;
51892 int ecode2 = 0 ;
51893 PyObject * obj0 = 0 ;
51894 PyObject * obj1 = 0 ;
51895 char * kwnames[] = {
51896 (char *) "self",(char *) "which", NULL
51897 };
51898
51899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51901 if (!SWIG_IsOK(res1)) {
51902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51903 }
51904 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51905 ecode2 = SWIG_AsVal_int(obj1, &val2);
51906 if (!SWIG_IsOK(ecode2)) {
51907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51908 }
51909 arg2 = static_cast< wxEdge >(val2);
51910 {
51911 PyThreadState* __tstate = wxPyBeginAllowThreads();
51912 (arg1)->SetEdge(arg2);
51913 wxPyEndAllowThreads(__tstate);
51914 if (PyErr_Occurred()) SWIG_fail;
51915 }
51916 resultobj = SWIG_Py_Void();
51917 return resultobj;
51918 fail:
51919 return NULL;
51920 }
51921
51922
51923 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51924 PyObject *resultobj = 0;
51925 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51926 int arg2 ;
51927 void *argp1 = 0 ;
51928 int res1 = 0 ;
51929 int val2 ;
51930 int ecode2 = 0 ;
51931 PyObject * obj0 = 0 ;
51932 PyObject * obj1 = 0 ;
51933 char * kwnames[] = {
51934 (char *) "self",(char *) "v", NULL
51935 };
51936
51937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51939 if (!SWIG_IsOK(res1)) {
51940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51941 }
51942 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51943 ecode2 = SWIG_AsVal_int(obj1, &val2);
51944 if (!SWIG_IsOK(ecode2)) {
51945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51946 }
51947 arg2 = static_cast< int >(val2);
51948 {
51949 PyThreadState* __tstate = wxPyBeginAllowThreads();
51950 (arg1)->SetValue(arg2);
51951 wxPyEndAllowThreads(__tstate);
51952 if (PyErr_Occurred()) SWIG_fail;
51953 }
51954 resultobj = SWIG_Py_Void();
51955 return resultobj;
51956 fail:
51957 return NULL;
51958 }
51959
51960
51961 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51962 PyObject *resultobj = 0;
51963 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51964 int result;
51965 void *argp1 = 0 ;
51966 int res1 = 0 ;
51967 PyObject *swig_obj[1] ;
51968
51969 if (!args) SWIG_fail;
51970 swig_obj[0] = args;
51971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51972 if (!SWIG_IsOK(res1)) {
51973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51974 }
51975 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51976 {
51977 PyThreadState* __tstate = wxPyBeginAllowThreads();
51978 result = (int)(arg1)->GetMargin();
51979 wxPyEndAllowThreads(__tstate);
51980 if (PyErr_Occurred()) SWIG_fail;
51981 }
51982 resultobj = SWIG_From_int(static_cast< int >(result));
51983 return resultobj;
51984 fail:
51985 return NULL;
51986 }
51987
51988
51989 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51990 PyObject *resultobj = 0;
51991 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51992 int arg2 ;
51993 void *argp1 = 0 ;
51994 int res1 = 0 ;
51995 int val2 ;
51996 int ecode2 = 0 ;
51997 PyObject * obj0 = 0 ;
51998 PyObject * obj1 = 0 ;
51999 char * kwnames[] = {
52000 (char *) "self",(char *) "m", NULL
52001 };
52002
52003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52005 if (!SWIG_IsOK(res1)) {
52006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52007 }
52008 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52009 ecode2 = SWIG_AsVal_int(obj1, &val2);
52010 if (!SWIG_IsOK(ecode2)) {
52011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52012 }
52013 arg2 = static_cast< int >(val2);
52014 {
52015 PyThreadState* __tstate = wxPyBeginAllowThreads();
52016 (arg1)->SetMargin(arg2);
52017 wxPyEndAllowThreads(__tstate);
52018 if (PyErr_Occurred()) SWIG_fail;
52019 }
52020 resultobj = SWIG_Py_Void();
52021 return resultobj;
52022 fail:
52023 return NULL;
52024 }
52025
52026
52027 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52028 PyObject *resultobj = 0;
52029 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52030 int result;
52031 void *argp1 = 0 ;
52032 int res1 = 0 ;
52033 PyObject *swig_obj[1] ;
52034
52035 if (!args) SWIG_fail;
52036 swig_obj[0] = args;
52037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52038 if (!SWIG_IsOK(res1)) {
52039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52040 }
52041 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52042 {
52043 PyThreadState* __tstate = wxPyBeginAllowThreads();
52044 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52045 wxPyEndAllowThreads(__tstate);
52046 if (PyErr_Occurred()) SWIG_fail;
52047 }
52048 resultobj = SWIG_From_int(static_cast< int >(result));
52049 return resultobj;
52050 fail:
52051 return NULL;
52052 }
52053
52054
52055 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52056 PyObject *resultobj = 0;
52057 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52058 int result;
52059 void *argp1 = 0 ;
52060 int res1 = 0 ;
52061 PyObject *swig_obj[1] ;
52062
52063 if (!args) SWIG_fail;
52064 swig_obj[0] = args;
52065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52066 if (!SWIG_IsOK(res1)) {
52067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52068 }
52069 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52070 {
52071 PyThreadState* __tstate = wxPyBeginAllowThreads();
52072 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52073 wxPyEndAllowThreads(__tstate);
52074 if (PyErr_Occurred()) SWIG_fail;
52075 }
52076 resultobj = SWIG_From_int(static_cast< int >(result));
52077 return resultobj;
52078 fail:
52079 return NULL;
52080 }
52081
52082
52083 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52084 PyObject *resultobj = 0;
52085 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52086 int result;
52087 void *argp1 = 0 ;
52088 int res1 = 0 ;
52089 PyObject *swig_obj[1] ;
52090
52091 if (!args) SWIG_fail;
52092 swig_obj[0] = args;
52093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52094 if (!SWIG_IsOK(res1)) {
52095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52096 }
52097 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52098 {
52099 PyThreadState* __tstate = wxPyBeginAllowThreads();
52100 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52101 wxPyEndAllowThreads(__tstate);
52102 if (PyErr_Occurred()) SWIG_fail;
52103 }
52104 resultobj = SWIG_From_int(static_cast< int >(result));
52105 return resultobj;
52106 fail:
52107 return NULL;
52108 }
52109
52110
52111 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52112 PyObject *resultobj = 0;
52113 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52114 bool result;
52115 void *argp1 = 0 ;
52116 int res1 = 0 ;
52117 PyObject *swig_obj[1] ;
52118
52119 if (!args) SWIG_fail;
52120 swig_obj[0] = args;
52121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52122 if (!SWIG_IsOK(res1)) {
52123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52124 }
52125 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52126 {
52127 PyThreadState* __tstate = wxPyBeginAllowThreads();
52128 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52129 wxPyEndAllowThreads(__tstate);
52130 if (PyErr_Occurred()) SWIG_fail;
52131 }
52132 {
52133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52134 }
52135 return resultobj;
52136 fail:
52137 return NULL;
52138 }
52139
52140
52141 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52142 PyObject *resultobj = 0;
52143 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52144 bool arg2 ;
52145 void *argp1 = 0 ;
52146 int res1 = 0 ;
52147 bool val2 ;
52148 int ecode2 = 0 ;
52149 PyObject * obj0 = 0 ;
52150 PyObject * obj1 = 0 ;
52151 char * kwnames[] = {
52152 (char *) "self",(char *) "d", NULL
52153 };
52154
52155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52157 if (!SWIG_IsOK(res1)) {
52158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52159 }
52160 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52161 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52162 if (!SWIG_IsOK(ecode2)) {
52163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52164 }
52165 arg2 = static_cast< bool >(val2);
52166 {
52167 PyThreadState* __tstate = wxPyBeginAllowThreads();
52168 (arg1)->SetDone(arg2);
52169 wxPyEndAllowThreads(__tstate);
52170 if (PyErr_Occurred()) SWIG_fail;
52171 }
52172 resultobj = SWIG_Py_Void();
52173 return resultobj;
52174 fail:
52175 return NULL;
52176 }
52177
52178
52179 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52180 PyObject *resultobj = 0;
52181 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52182 wxRelationship result;
52183 void *argp1 = 0 ;
52184 int res1 = 0 ;
52185 PyObject *swig_obj[1] ;
52186
52187 if (!args) SWIG_fail;
52188 swig_obj[0] = args;
52189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52190 if (!SWIG_IsOK(res1)) {
52191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52192 }
52193 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52194 {
52195 PyThreadState* __tstate = wxPyBeginAllowThreads();
52196 result = (wxRelationship)(arg1)->GetRelationship();
52197 wxPyEndAllowThreads(__tstate);
52198 if (PyErr_Occurred()) SWIG_fail;
52199 }
52200 resultobj = SWIG_From_int(static_cast< int >(result));
52201 return resultobj;
52202 fail:
52203 return NULL;
52204 }
52205
52206
52207 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52208 PyObject *resultobj = 0;
52209 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52210 wxRelationship arg2 ;
52211 void *argp1 = 0 ;
52212 int res1 = 0 ;
52213 int val2 ;
52214 int ecode2 = 0 ;
52215 PyObject * obj0 = 0 ;
52216 PyObject * obj1 = 0 ;
52217 char * kwnames[] = {
52218 (char *) "self",(char *) "r", NULL
52219 };
52220
52221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52223 if (!SWIG_IsOK(res1)) {
52224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52225 }
52226 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52227 ecode2 = SWIG_AsVal_int(obj1, &val2);
52228 if (!SWIG_IsOK(ecode2)) {
52229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52230 }
52231 arg2 = static_cast< wxRelationship >(val2);
52232 {
52233 PyThreadState* __tstate = wxPyBeginAllowThreads();
52234 (arg1)->SetRelationship(arg2);
52235 wxPyEndAllowThreads(__tstate);
52236 if (PyErr_Occurred()) SWIG_fail;
52237 }
52238 resultobj = SWIG_Py_Void();
52239 return resultobj;
52240 fail:
52241 return NULL;
52242 }
52243
52244
52245 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52246 PyObject *resultobj = 0;
52247 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52248 wxWindow *arg2 = (wxWindow *) 0 ;
52249 bool result;
52250 void *argp1 = 0 ;
52251 int res1 = 0 ;
52252 void *argp2 = 0 ;
52253 int res2 = 0 ;
52254 PyObject * obj0 = 0 ;
52255 PyObject * obj1 = 0 ;
52256 char * kwnames[] = {
52257 (char *) "self",(char *) "otherW", NULL
52258 };
52259
52260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52262 if (!SWIG_IsOK(res1)) {
52263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52264 }
52265 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52266 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52267 if (!SWIG_IsOK(res2)) {
52268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52269 }
52270 arg2 = reinterpret_cast< wxWindow * >(argp2);
52271 {
52272 PyThreadState* __tstate = wxPyBeginAllowThreads();
52273 result = (bool)(arg1)->ResetIfWin(arg2);
52274 wxPyEndAllowThreads(__tstate);
52275 if (PyErr_Occurred()) SWIG_fail;
52276 }
52277 {
52278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52279 }
52280 return resultobj;
52281 fail:
52282 return NULL;
52283 }
52284
52285
52286 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52287 PyObject *resultobj = 0;
52288 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52289 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52290 wxWindow *arg3 = (wxWindow *) 0 ;
52291 bool result;
52292 void *argp1 = 0 ;
52293 int res1 = 0 ;
52294 void *argp2 = 0 ;
52295 int res2 = 0 ;
52296 void *argp3 = 0 ;
52297 int res3 = 0 ;
52298 PyObject * obj0 = 0 ;
52299 PyObject * obj1 = 0 ;
52300 PyObject * obj2 = 0 ;
52301 char * kwnames[] = {
52302 (char *) "self",(char *) "constraints",(char *) "win", NULL
52303 };
52304
52305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52307 if (!SWIG_IsOK(res1)) {
52308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52309 }
52310 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52311 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52312 if (!SWIG_IsOK(res2)) {
52313 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52314 }
52315 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52316 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52317 if (!SWIG_IsOK(res3)) {
52318 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52319 }
52320 arg3 = reinterpret_cast< wxWindow * >(argp3);
52321 {
52322 PyThreadState* __tstate = wxPyBeginAllowThreads();
52323 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52324 wxPyEndAllowThreads(__tstate);
52325 if (PyErr_Occurred()) SWIG_fail;
52326 }
52327 {
52328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52329 }
52330 return resultobj;
52331 fail:
52332 return NULL;
52333 }
52334
52335
52336 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52337 PyObject *resultobj = 0;
52338 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52339 wxEdge arg2 ;
52340 wxWindow *arg3 = (wxWindow *) 0 ;
52341 wxWindow *arg4 = (wxWindow *) 0 ;
52342 int result;
52343 void *argp1 = 0 ;
52344 int res1 = 0 ;
52345 int val2 ;
52346 int ecode2 = 0 ;
52347 void *argp3 = 0 ;
52348 int res3 = 0 ;
52349 void *argp4 = 0 ;
52350 int res4 = 0 ;
52351 PyObject * obj0 = 0 ;
52352 PyObject * obj1 = 0 ;
52353 PyObject * obj2 = 0 ;
52354 PyObject * obj3 = 0 ;
52355 char * kwnames[] = {
52356 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52357 };
52358
52359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52361 if (!SWIG_IsOK(res1)) {
52362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52363 }
52364 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52365 ecode2 = SWIG_AsVal_int(obj1, &val2);
52366 if (!SWIG_IsOK(ecode2)) {
52367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52368 }
52369 arg2 = static_cast< wxEdge >(val2);
52370 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52371 if (!SWIG_IsOK(res3)) {
52372 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52373 }
52374 arg3 = reinterpret_cast< wxWindow * >(argp3);
52375 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52376 if (!SWIG_IsOK(res4)) {
52377 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52378 }
52379 arg4 = reinterpret_cast< wxWindow * >(argp4);
52380 {
52381 PyThreadState* __tstate = wxPyBeginAllowThreads();
52382 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52383 wxPyEndAllowThreads(__tstate);
52384 if (PyErr_Occurred()) SWIG_fail;
52385 }
52386 resultobj = SWIG_From_int(static_cast< int >(result));
52387 return resultobj;
52388 fail:
52389 return NULL;
52390 }
52391
52392
52393 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52394 PyObject *obj;
52395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52396 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52397 return SWIG_Py_Void();
52398 }
52399
52400 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52401 PyObject *resultobj = 0;
52402 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52403 wxIndividualLayoutConstraint *result = 0 ;
52404 void *argp1 = 0 ;
52405 int res1 = 0 ;
52406 PyObject *swig_obj[1] ;
52407
52408 if (!args) SWIG_fail;
52409 swig_obj[0] = args;
52410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52411 if (!SWIG_IsOK(res1)) {
52412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52413 }
52414 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52415 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52417 return resultobj;
52418 fail:
52419 return NULL;
52420 }
52421
52422
52423 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52424 PyObject *resultobj = 0;
52425 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52426 wxIndividualLayoutConstraint *result = 0 ;
52427 void *argp1 = 0 ;
52428 int res1 = 0 ;
52429 PyObject *swig_obj[1] ;
52430
52431 if (!args) SWIG_fail;
52432 swig_obj[0] = args;
52433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52434 if (!SWIG_IsOK(res1)) {
52435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52436 }
52437 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52438 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52439 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52440 return resultobj;
52441 fail:
52442 return NULL;
52443 }
52444
52445
52446 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52447 PyObject *resultobj = 0;
52448 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52449 wxIndividualLayoutConstraint *result = 0 ;
52450 void *argp1 = 0 ;
52451 int res1 = 0 ;
52452 PyObject *swig_obj[1] ;
52453
52454 if (!args) SWIG_fail;
52455 swig_obj[0] = args;
52456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52457 if (!SWIG_IsOK(res1)) {
52458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52459 }
52460 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52461 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52463 return resultobj;
52464 fail:
52465 return NULL;
52466 }
52467
52468
52469 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52470 PyObject *resultobj = 0;
52471 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52472 wxIndividualLayoutConstraint *result = 0 ;
52473 void *argp1 = 0 ;
52474 int res1 = 0 ;
52475 PyObject *swig_obj[1] ;
52476
52477 if (!args) SWIG_fail;
52478 swig_obj[0] = args;
52479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52480 if (!SWIG_IsOK(res1)) {
52481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52482 }
52483 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52484 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52486 return resultobj;
52487 fail:
52488 return NULL;
52489 }
52490
52491
52492 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52493 PyObject *resultobj = 0;
52494 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52495 wxIndividualLayoutConstraint *result = 0 ;
52496 void *argp1 = 0 ;
52497 int res1 = 0 ;
52498 PyObject *swig_obj[1] ;
52499
52500 if (!args) SWIG_fail;
52501 swig_obj[0] = args;
52502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52503 if (!SWIG_IsOK(res1)) {
52504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52505 }
52506 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52507 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52509 return resultobj;
52510 fail:
52511 return NULL;
52512 }
52513
52514
52515 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52516 PyObject *resultobj = 0;
52517 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52518 wxIndividualLayoutConstraint *result = 0 ;
52519 void *argp1 = 0 ;
52520 int res1 = 0 ;
52521 PyObject *swig_obj[1] ;
52522
52523 if (!args) SWIG_fail;
52524 swig_obj[0] = args;
52525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52526 if (!SWIG_IsOK(res1)) {
52527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52528 }
52529 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52530 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52532 return resultobj;
52533 fail:
52534 return NULL;
52535 }
52536
52537
52538 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52539 PyObject *resultobj = 0;
52540 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52541 wxIndividualLayoutConstraint *result = 0 ;
52542 void *argp1 = 0 ;
52543 int res1 = 0 ;
52544 PyObject *swig_obj[1] ;
52545
52546 if (!args) SWIG_fail;
52547 swig_obj[0] = args;
52548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52549 if (!SWIG_IsOK(res1)) {
52550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52551 }
52552 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52553 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52555 return resultobj;
52556 fail:
52557 return NULL;
52558 }
52559
52560
52561 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52562 PyObject *resultobj = 0;
52563 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52564 wxIndividualLayoutConstraint *result = 0 ;
52565 void *argp1 = 0 ;
52566 int res1 = 0 ;
52567 PyObject *swig_obj[1] ;
52568
52569 if (!args) SWIG_fail;
52570 swig_obj[0] = args;
52571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52572 if (!SWIG_IsOK(res1)) {
52573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52574 }
52575 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52576 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52578 return resultobj;
52579 fail:
52580 return NULL;
52581 }
52582
52583
52584 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52585 PyObject *resultobj = 0;
52586 wxLayoutConstraints *result = 0 ;
52587
52588 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52589 {
52590 PyThreadState* __tstate = wxPyBeginAllowThreads();
52591 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52592 wxPyEndAllowThreads(__tstate);
52593 if (PyErr_Occurred()) SWIG_fail;
52594 }
52595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52596 return resultobj;
52597 fail:
52598 return NULL;
52599 }
52600
52601
52602 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52603 PyObject *resultobj = 0;
52604 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52605 void *argp1 = 0 ;
52606 int res1 = 0 ;
52607 PyObject *swig_obj[1] ;
52608
52609 if (!args) SWIG_fail;
52610 swig_obj[0] = args;
52611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52612 if (!SWIG_IsOK(res1)) {
52613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52614 }
52615 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52616 {
52617 PyThreadState* __tstate = wxPyBeginAllowThreads();
52618 delete arg1;
52619
52620 wxPyEndAllowThreads(__tstate);
52621 if (PyErr_Occurred()) SWIG_fail;
52622 }
52623 resultobj = SWIG_Py_Void();
52624 return resultobj;
52625 fail:
52626 return NULL;
52627 }
52628
52629
52630 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52631 PyObject *resultobj = 0;
52632 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52633 wxWindow *arg2 = (wxWindow *) 0 ;
52634 int *arg3 = (int *) 0 ;
52635 bool result;
52636 void *argp1 = 0 ;
52637 int res1 = 0 ;
52638 void *argp2 = 0 ;
52639 int res2 = 0 ;
52640 int temp3 ;
52641 int res3 = SWIG_TMPOBJ ;
52642 PyObject * obj0 = 0 ;
52643 PyObject * obj1 = 0 ;
52644 char * kwnames[] = {
52645 (char *) "self",(char *) "win", NULL
52646 };
52647
52648 arg3 = &temp3;
52649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52651 if (!SWIG_IsOK(res1)) {
52652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52653 }
52654 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52655 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52656 if (!SWIG_IsOK(res2)) {
52657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52658 }
52659 arg2 = reinterpret_cast< wxWindow * >(argp2);
52660 {
52661 PyThreadState* __tstate = wxPyBeginAllowThreads();
52662 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52663 wxPyEndAllowThreads(__tstate);
52664 if (PyErr_Occurred()) SWIG_fail;
52665 }
52666 {
52667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52668 }
52669 if (SWIG_IsTmpObj(res3)) {
52670 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52671 } else {
52672 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52673 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52674 }
52675 return resultobj;
52676 fail:
52677 return NULL;
52678 }
52679
52680
52681 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52682 PyObject *resultobj = 0;
52683 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52684 bool result;
52685 void *argp1 = 0 ;
52686 int res1 = 0 ;
52687 PyObject *swig_obj[1] ;
52688
52689 if (!args) SWIG_fail;
52690 swig_obj[0] = args;
52691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52692 if (!SWIG_IsOK(res1)) {
52693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52694 }
52695 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52696 {
52697 PyThreadState* __tstate = wxPyBeginAllowThreads();
52698 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52699 wxPyEndAllowThreads(__tstate);
52700 if (PyErr_Occurred()) SWIG_fail;
52701 }
52702 {
52703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52704 }
52705 return resultobj;
52706 fail:
52707 return NULL;
52708 }
52709
52710
52711 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52712 PyObject *obj;
52713 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52714 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52715 return SWIG_Py_Void();
52716 }
52717
52718 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52719 return SWIG_Python_InitShadowInstance(args);
52720 }
52721
52722 static PyMethodDef SwigMethods[] = {
52723 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52724 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52725 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52726 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52727 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52728 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52729 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52730 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52731 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52732 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52733 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52734 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52735 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52736 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52737 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52738 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52739 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52740 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52741 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52743 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52744 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52745 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52746 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52747 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52748 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52749 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52750 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52751 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52752 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52753 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52754 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52755 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52756 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52757 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52758 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52759 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52760 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52761 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52762 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52763 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52764 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52765 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52766 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52767 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52769 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52770 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52771 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52772 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52773 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52774 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52775 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52776 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52777 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52778 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52779 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52780 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52781 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52783 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52784 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52785 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52786 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52787 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52788 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52789 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52790 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52791 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52792 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52793 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52795 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52796 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52797 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52798 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52799 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52800 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52801 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52802 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52803 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52804 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52805 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52813 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52815 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52822 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52823 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52824 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52825 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52826 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52827 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52828 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52829 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52830 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52831 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52832 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52833 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52834 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52835 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52839 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52840 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52841 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52842 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52843 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52849 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52850 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52851 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52853 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52855 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52857 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52858 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52859 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52860 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52862 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52863 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52864 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52866 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52867 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52868 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52869 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52870 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52871 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52874 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52875 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52876 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52877 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52878 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52879 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52882 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52883 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52884 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52886 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52887 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52889 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52890 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52891 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52892 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52893 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52894 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52895 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52896 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52897 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52898 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52899 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52900 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52901 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52902 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52903 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52904 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52905 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52909 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52910 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52911 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52912 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52913 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52915 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52916 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52917 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52918 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52919 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52920 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52921 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52923 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52924 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52925 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52926 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52928 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52929 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52930 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52933 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52934 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52935 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52936 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52940 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52943 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52945 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52946 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52947 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52948 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52949 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52950 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52951 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52954 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52956 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52958 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52959 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52961 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52962 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52963 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52964 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52966 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52967 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52969 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52970 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52971 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52972 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52973 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52974 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52975 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52976 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52977 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52978 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52979 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52980 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52981 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52982 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52983 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52984 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52985 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52986 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52987 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52988 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52989 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52990 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52991 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52992 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52994 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52995 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52996 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52998 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52999 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53000 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53003 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53004 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53005 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53008 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53009 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53011 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53012 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53015 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53016 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53018 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53019 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53021 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53025 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53027 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53028 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53029 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53030 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53033 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53035 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53037 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53038 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53039 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53040 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53041 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53042 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53044 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53045 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53046 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53047 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53048 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53049 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53050 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53051 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53054 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53064 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53066 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53067 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53073 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53074 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53075 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53076 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53077 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53078 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53079 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53080 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53081 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53082 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53083 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53084 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53085 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53086 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53087 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53088 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53089 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53090 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53091 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53092 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53093 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53094 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53095 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53096 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53097 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53098 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53099 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53100 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53101 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53102 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53103 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53104 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53105 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53106 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53107 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53109 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53110 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53111 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53112 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53115 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53116 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53119 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53123 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53124 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53125 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53126 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53128 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53129 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53131 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53133 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53135 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53137 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53138 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53139 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53141 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53142 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53144 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53145 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53146 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53148 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53149 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53150 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53152 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53154 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53155 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53156 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53158 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53160 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53161 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53163 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53164 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53165 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53167 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53168 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53169 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53170 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53171 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53173 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53174 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53177 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53178 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53179 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53180 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53181 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53184 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53185 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53187 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53193 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53194 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53195 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53196 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53197 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53198 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53199 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53200 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53201 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53202 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53203 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53204 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53205 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53206 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53207 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53208 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53209 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53210 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53211 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53212 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53213 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53214 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53215 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53216 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53217 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53218 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53219 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53220 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53221 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53222 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53223 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53224 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53225 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53226 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53227 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53228 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53229 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53230 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53231 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53232 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53233 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53234 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53235 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53236 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53237 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53238 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53239 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53240 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53241 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53242 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53243 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53244 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53245 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53246 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53247 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53248 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53249 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53251 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53252 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53253 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53254 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53255 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53256 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53257 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53259 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53260 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53261 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53262 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53263 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53264 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53265 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53266 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53267 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53268 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53269 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53270 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53271 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53272 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53273 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53274 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53275 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53276 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53277 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53278 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53279 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53280 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53281 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53282 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53283 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53284 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53285 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53286 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53287 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53288 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53289 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53290 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53291 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53292 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53293 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53294 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53295 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53296 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53298 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53299 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53300 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53302 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53303 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53304 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53305 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53306 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53307 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53309 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53310 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53311 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53313 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53314 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53316 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53317 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53319 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53320 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53322 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53323 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53324 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53326 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53328 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53329 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53331 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53332 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53333 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53335 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53336 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53337 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53339 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53340 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53341 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53342 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53343 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53344 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53345 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53346 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53349 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53351 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53353 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53354 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53355 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53358 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53359 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53360 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53362 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53363 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53364 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53366 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53367 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53368 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53369 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53370 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53371 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53373 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53374 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53375 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53376 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53377 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53378 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53379 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53380 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53386 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53388 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53390 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53391 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53392 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53393 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53394 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53395 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53396 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53397 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53398 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53399 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53400 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53401 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53402 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53405 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53406 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53407 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53410 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53411 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53412 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53413 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53414 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53416 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53418 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53421 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53423 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53424 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53426 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53427 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53428 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53430 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53431 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53432 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53434 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53436 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53437 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53438 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53440 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53442 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53444 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53445 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53447 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53448 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53450 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53452 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53453 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53454 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53456 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53458 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53459 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53460 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53462 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53464 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53465 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53466 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53467 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53469 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53471 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53473 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53475 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53476 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53478 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53479 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53480 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53481 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53482 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53483 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53484 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53485 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53487 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53489 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53491 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53493 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53495 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53497 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53498 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53499 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53500 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53501 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53502 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53508 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53509 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53510 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53511 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53512 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53513 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53514 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53516 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53518 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53519 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53521 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53522 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53523 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53524 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53526 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53527 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53528 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53529 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53531 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53532 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53534 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53535 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53536 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53538 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53540 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53541 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53542 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53543 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53544 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53546 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53547 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53548 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53549 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53551 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53552 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53553 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53554 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53555 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53556 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53557 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53558 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53559 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53560 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53562 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53564 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53565 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53566 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53567 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53569 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53571 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53573 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53575 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53576 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53586 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53587 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53591 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53592 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53593 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53594 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53595 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53596 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53597 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53598 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53599 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53600 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53601 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53602 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53603 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53604 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53605 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53607 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53608 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53611 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53612 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53617 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53618 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53619 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53621 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53622 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53623 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53624 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53626 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53627 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53628 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53629 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53631 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53633 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53634 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53635 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53637 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53639 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53641 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53644 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53645 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53646 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53647 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53648 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53649 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53650 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53656 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53657 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53658 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53659 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53666 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53672 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53673 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53674 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53675 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53676 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53678 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53688 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53689 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53690 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53691 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53694 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53695 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53696 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53697 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53699 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53700 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53701 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53704 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53710 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53711 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53712 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53713 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53715 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53716 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53718 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53721 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53723 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53724 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53725 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53734 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53738 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53740 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53750 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53751 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53752 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53753 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53757 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53760 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53762 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53765 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53767 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53768 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53771 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53773 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53774 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53775 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53776 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53777 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53782 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53783 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53784 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53786 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53787 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53788 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53790 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53792 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53793 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53794 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53796 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53797 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53800 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53808 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53815 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53823 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53826 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53827 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53840 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53842 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53844 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53845 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53847 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53849 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53850 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53852 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53853 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53854 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53858 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53877 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53878 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53880 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53882 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53883 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53884 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53886 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53887 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53890 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53891 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53893 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53894 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53896 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53899 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53900 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53902 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53904 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53906 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53907 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53909 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53910 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53913 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53915 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53917 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53919 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53922 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53924 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53925 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53926 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53928 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53929 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53930 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53932 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53935 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53937 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53938 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53942 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53946 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53947 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53949 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53953 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53955 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53957 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53958 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53959 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53960 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53964 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53965 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53966 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53967 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53969 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53970 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53975 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53976 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53977 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53978 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53979 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53981 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53983 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53985 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53986 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53988 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53990 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53993 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53994 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53995 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53997 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53998 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53999 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54013 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54014 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54015 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54016 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54017 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54018 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54021 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54024 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54025 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54029 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54030 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54032 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54033 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54035 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54037 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54038 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54040 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54041 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54042 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54047 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54048 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54049 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54050 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54051 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54052 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54053 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54060 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54062 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54063 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54064 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54065 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54066 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54067 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54069 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54073 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54074 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54075 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54076 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54077 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54078 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54079 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54081 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54082 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54083 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54089 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54090 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54091 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54093 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54094 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54095 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54097 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54098 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54099 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54100 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54101 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54102 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54103 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54104 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54105 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54106 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54107 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54108 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54109 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54110 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54114 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54115 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54116 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54118 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54119 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54120 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54124 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54125 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54126 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54127 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54128 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54129 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54130 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54135 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54136 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54145 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54146 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54147 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54148 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54151 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54153 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54154 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54155 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54156 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54158 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54163 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54164 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54165 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54166 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54167 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54168 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54169 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54170 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54171 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54172 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54173 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54174 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54175 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54176 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54177 { NULL, NULL, 0, NULL }
54178 };
54179
54180
54181 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54182
54183 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54184 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54185 }
54186 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54187 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54188 }
54189 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54190 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54191 }
54192 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54193 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54194 }
54195 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54196 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54197 }
54198 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54199 return (void *)((wxSizer *) ((wxGridSizer *) x));
54200 }
54201 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54202 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54203 }
54204 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54205 return (void *)((wxSizer *) ((wxPySizer *) x));
54206 }
54207 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54208 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54209 }
54210 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54211 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54212 }
54213 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54214 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54215 }
54216 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54217 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54218 }
54219 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54220 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54221 }
54222 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54223 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54224 }
54225 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54226 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54227 }
54228 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54229 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54230 }
54231 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54232 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54233 }
54234 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54235 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54236 }
54237 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54238 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54239 }
54240 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54241 return (void *)((wxEvent *) ((wxPyEvent *) x));
54242 }
54243 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54244 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54245 }
54246 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54247 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54248 }
54249 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54250 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54251 }
54252 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54253 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54254 }
54255 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54256 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54257 }
54258 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54259 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54260 }
54261 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54262 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54263 }
54264 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54265 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54266 }
54267 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54268 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54269 }
54270 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54271 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54272 }
54273 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54274 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54275 }
54276 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54277 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54278 }
54279 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54280 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54281 }
54282 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54283 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54284 }
54285 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54286 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54287 }
54288 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54289 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54290 }
54291 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54292 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54293 }
54294 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54295 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54296 }
54297 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54298 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54299 }
54300 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54301 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54302 }
54303 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54304 return (void *)((wxEvent *) ((wxShowEvent *) x));
54305 }
54306 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54307 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54308 }
54309 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54310 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54311 }
54312 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54313 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54314 }
54315 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54316 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54317 }
54318 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54319 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54320 }
54321 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54322 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54323 }
54324 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54325 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54326 }
54327 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54328 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54329 }
54330 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54331 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54332 }
54333 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54334 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54335 }
54336 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54337 return (void *)((wxControl *) ((wxControlWithItems *) x));
54338 }
54339 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54340 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54341 }
54342 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54343 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54344 }
54345 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54346 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54347 }
54348 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54349 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54350 }
54351 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54352 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54353 }
54354 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54355 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54356 }
54357 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54358 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54359 }
54360 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54361 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54362 }
54363 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54364 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54365 }
54366 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54367 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54368 }
54369 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54370 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54371 }
54372 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54373 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54374 }
54375 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54376 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54377 }
54378 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54379 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54380 }
54381 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54382 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54383 }
54384 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54385 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54386 }
54387 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54388 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54389 }
54390 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54391 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54392 }
54393 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54394 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54395 }
54396 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54397 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54398 }
54399 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54400 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54401 }
54402 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54403 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54404 }
54405 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54406 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54407 }
54408 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54409 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54410 }
54411 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54412 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54413 }
54414 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54415 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54416 }
54417 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54418 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54419 }
54420 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54421 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54422 }
54423 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54424 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54425 }
54426 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54427 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54428 }
54429 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54430 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54431 }
54432 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54433 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54434 }
54435 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54436 return (void *)((wxObject *) ((wxSizerItem *) x));
54437 }
54438 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54439 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54440 }
54441 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54442 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54443 }
54444 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54445 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54446 }
54447 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54448 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54449 }
54450 static void *_p_wxSizerTo_p_wxObject(void *x) {
54451 return (void *)((wxObject *) ((wxSizer *) x));
54452 }
54453 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54454 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54455 }
54456 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54457 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54458 }
54459 static void *_p_wxEventTo_p_wxObject(void *x) {
54460 return (void *)((wxObject *) ((wxEvent *) x));
54461 }
54462 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54463 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54464 }
54465 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54466 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54467 }
54468 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54469 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54470 }
54471 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54472 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54473 }
54474 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54475 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54476 }
54477 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54478 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54479 }
54480 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54481 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54482 }
54483 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54484 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54485 }
54486 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54487 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54488 }
54489 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54490 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54491 }
54492 static void *_p_wxControlTo_p_wxObject(void *x) {
54493 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54494 }
54495 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54496 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54497 }
54498 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54499 return (void *)((wxObject *) ((wxFSFile *) x));
54500 }
54501 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54502 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54503 }
54504 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54505 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54506 }
54507 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54508 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54509 }
54510 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54511 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54512 }
54513 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54514 return (void *)((wxObject *) ((wxMenuItem *) x));
54515 }
54516 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54517 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54518 }
54519 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54520 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54521 }
54522 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54523 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54524 }
54525 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54526 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54527 }
54528 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54529 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54530 }
54531 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54532 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54533 }
54534 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54535 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54536 }
54537 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54538 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54539 }
54540 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54541 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54542 }
54543 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54544 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54545 }
54546 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54547 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54548 }
54549 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54550 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54551 }
54552 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54553 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54554 }
54555 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54556 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54557 }
54558 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54559 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54560 }
54561 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54562 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54563 }
54564 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54565 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54566 }
54567 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54568 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54569 }
54570 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54571 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54572 }
54573 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54574 return (void *)((wxObject *) ((wxImageHandler *) x));
54575 }
54576 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54577 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54578 }
54579 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54580 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54581 }
54582 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54583 return (void *)((wxObject *) ((wxEvtHandler *) x));
54584 }
54585 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54586 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54587 }
54588 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54589 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54590 }
54591 static void *_p_wxImageTo_p_wxObject(void *x) {
54592 return (void *)((wxObject *) ((wxImage *) x));
54593 }
54594 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54595 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54596 }
54597 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54598 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54599 }
54600 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54601 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54602 }
54603 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54604 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54605 }
54606 static void *_p_wxWindowTo_p_wxObject(void *x) {
54607 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54608 }
54609 static void *_p_wxMenuTo_p_wxObject(void *x) {
54610 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54611 }
54612 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54613 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54614 }
54615 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54616 return (void *)((wxObject *) ((wxFileSystem *) x));
54617 }
54618 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54619 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54620 }
54621 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54622 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54623 }
54624 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54625 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54626 }
54627 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54628 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54629 }
54630 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54631 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54632 }
54633 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54634 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54635 }
54636 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54637 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54638 }
54639 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54640 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54641 }
54642 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54643 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54644 }
54645 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54646 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54647 }
54648 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54649 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54650 }
54651 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54652 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54653 }
54654 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54655 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54656 }
54657 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54658 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54659 }
54660 static void *_p_wxControlTo_p_wxWindow(void *x) {
54661 return (void *)((wxWindow *) ((wxControl *) x));
54662 }
54663 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54664 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54665 }
54666 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54667 return (void *)((wxWindow *) ((wxMenuBar *) x));
54668 }
54669 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54670 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54671 }
54672 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54673 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54674 }
54675 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54676 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54677 }
54678 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54679 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54680 }
54681 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54682 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54683 }
54684 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54685 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54686 }
54687 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54688 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54689 }
54690 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54691 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54692 }
54693 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54694 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54695 }
54696 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54697 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54698 }
54699 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54700 return (void *)((wxValidator *) ((wxPyValidator *) x));
54701 }
54702 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54703 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54704 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};
54705 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54706 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54707 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54708 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54709 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54710 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54711 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54712 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54713 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54714 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54715 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54716 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54717 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54718 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54719 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54720 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54721 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54722 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54723 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54724 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54725 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54726 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54727 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54728 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54729 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54730 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54731 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54732 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54733 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54734 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54735 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54736 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54737 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54738 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54739 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54740 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54741 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54742 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54743 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54744 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54745 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54746 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54747 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54748 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54749 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54750 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54751 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54752 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54753 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54754 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54755 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54756 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54757 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54758 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54759 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54760 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54761 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54762 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54763 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54764 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54765 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54766 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54767 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54768 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54769 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54770 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54771 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54772 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54773 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54774 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54775 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54776 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54777 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54778 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54779 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54780 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54781 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54782 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54783 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54784 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54785 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54786 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54787 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54788 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54789 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54790 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54791 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54792 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54793 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54794 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54795 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54796 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54797 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54798 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54799 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54800 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54801 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54802 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54803 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54804 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54805 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54806 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54807 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54808 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54809 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54810 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54811 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54812 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54813 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54814 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54815 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54816 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54817 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54818 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54819 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54820 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54821 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54822 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54823 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54824 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54825 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54826 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54827 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54828 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54829 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54830 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54831 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54832 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54833
54834 static swig_type_info *swig_type_initial[] = {
54835 &_swigt__p_buffer,
54836 &_swigt__p_char,
54837 &_swigt__p_form_ops_t,
54838 &_swigt__p_int,
54839 &_swigt__p_long,
54840 &_swigt__p_unsigned_char,
54841 &_swigt__p_unsigned_int,
54842 &_swigt__p_unsigned_long,
54843 &_swigt__p_wxANIHandler,
54844 &_swigt__p_wxAcceleratorEntry,
54845 &_swigt__p_wxAcceleratorTable,
54846 &_swigt__p_wxActivateEvent,
54847 &_swigt__p_wxAppTraits,
54848 &_swigt__p_wxArrayString,
54849 &_swigt__p_wxBMPHandler,
54850 &_swigt__p_wxBitmap,
54851 &_swigt__p_wxBoxSizer,
54852 &_swigt__p_wxButton,
54853 &_swigt__p_wxCURHandler,
54854 &_swigt__p_wxCaret,
54855 &_swigt__p_wxChildFocusEvent,
54856 &_swigt__p_wxClipboardTextEvent,
54857 &_swigt__p_wxCloseEvent,
54858 &_swigt__p_wxColour,
54859 &_swigt__p_wxCommandEvent,
54860 &_swigt__p_wxContextMenuEvent,
54861 &_swigt__p_wxControl,
54862 &_swigt__p_wxControlWithItems,
54863 &_swigt__p_wxCursor,
54864 &_swigt__p_wxDC,
54865 &_swigt__p_wxDateEvent,
54866 &_swigt__p_wxDateTime,
54867 &_swigt__p_wxDisplayChangedEvent,
54868 &_swigt__p_wxDropFilesEvent,
54869 &_swigt__p_wxDuplexMode,
54870 &_swigt__p_wxEraseEvent,
54871 &_swigt__p_wxEvent,
54872 &_swigt__p_wxEventLoop,
54873 &_swigt__p_wxEventLoopActivator,
54874 &_swigt__p_wxEvtHandler,
54875 &_swigt__p_wxFSFile,
54876 &_swigt__p_wxFileSystem,
54877 &_swigt__p_wxFileSystemHandler,
54878 &_swigt__p_wxFlexGridSizer,
54879 &_swigt__p_wxFocusEvent,
54880 &_swigt__p_wxFont,
54881 &_swigt__p_wxFrame,
54882 &_swigt__p_wxGBPosition,
54883 &_swigt__p_wxGBSizerItem,
54884 &_swigt__p_wxGBSpan,
54885 &_swigt__p_wxGIFHandler,
54886 &_swigt__p_wxGridBagSizer,
54887 &_swigt__p_wxGridSizer,
54888 &_swigt__p_wxHelpEvent__Origin,
54889 &_swigt__p_wxICOHandler,
54890 &_swigt__p_wxIconizeEvent,
54891 &_swigt__p_wxIdleEvent,
54892 &_swigt__p_wxImage,
54893 &_swigt__p_wxImageHandler,
54894 &_swigt__p_wxImageHistogram,
54895 &_swigt__p_wxImage_HSVValue,
54896 &_swigt__p_wxImage_RGBValue,
54897 &_swigt__p_wxIndividualLayoutConstraint,
54898 &_swigt__p_wxInitDialogEvent,
54899 &_swigt__p_wxInputStream,
54900 &_swigt__p_wxInternetFSHandler,
54901 &_swigt__p_wxItemContainer,
54902 &_swigt__p_wxJPEGHandler,
54903 &_swigt__p_wxKeyEvent,
54904 &_swigt__p_wxLayoutConstraints,
54905 &_swigt__p_wxMaximizeEvent,
54906 &_swigt__p_wxMemoryFSHandler,
54907 &_swigt__p_wxMenu,
54908 &_swigt__p_wxMenuBar,
54909 &_swigt__p_wxMenuBarBase,
54910 &_swigt__p_wxMenuEvent,
54911 &_swigt__p_wxMenuItem,
54912 &_swigt__p_wxMouseCaptureChangedEvent,
54913 &_swigt__p_wxMouseEvent,
54914 &_swigt__p_wxMoveEvent,
54915 &_swigt__p_wxNavigationKeyEvent,
54916 &_swigt__p_wxNcPaintEvent,
54917 &_swigt__p_wxNotifyEvent,
54918 &_swigt__p_wxObject,
54919 &_swigt__p_wxOutputStream,
54920 &_swigt__p_wxPCXHandler,
54921 &_swigt__p_wxPNGHandler,
54922 &_swigt__p_wxPNMHandler,
54923 &_swigt__p_wxPaintEvent,
54924 &_swigt__p_wxPaletteChangedEvent,
54925 &_swigt__p_wxPaperSize,
54926 &_swigt__p_wxPoint,
54927 &_swigt__p_wxPoint2D,
54928 &_swigt__p_wxPropagateOnce,
54929 &_swigt__p_wxPropagationDisabler,
54930 &_swigt__p_wxPyApp,
54931 &_swigt__p_wxPyCommandEvent,
54932 &_swigt__p_wxPyDropTarget,
54933 &_swigt__p_wxPyEvent,
54934 &_swigt__p_wxPyFileSystemHandler,
54935 &_swigt__p_wxPyImageHandler,
54936 &_swigt__p_wxPyInputStream,
54937 &_swigt__p_wxPySizer,
54938 &_swigt__p_wxPyValidator,
54939 &_swigt__p_wxQuantize,
54940 &_swigt__p_wxQueryNewPaletteEvent,
54941 &_swigt__p_wxRealPoint,
54942 &_swigt__p_wxRect,
54943 &_swigt__p_wxRegion,
54944 &_swigt__p_wxScrollEvent,
54945 &_swigt__p_wxScrollWinEvent,
54946 &_swigt__p_wxSetCursorEvent,
54947 &_swigt__p_wxShowEvent,
54948 &_swigt__p_wxSize,
54949 &_swigt__p_wxSizeEvent,
54950 &_swigt__p_wxSizer,
54951 &_swigt__p_wxSizerItem,
54952 &_swigt__p_wxStaticBox,
54953 &_swigt__p_wxStaticBoxSizer,
54954 &_swigt__p_wxStdDialogButtonSizer,
54955 &_swigt__p_wxSysColourChangedEvent,
54956 &_swigt__p_wxTIFFHandler,
54957 &_swigt__p_wxToolTip,
54958 &_swigt__p_wxUpdateUIEvent,
54959 &_swigt__p_wxValidator,
54960 &_swigt__p_wxVisualAttributes,
54961 &_swigt__p_wxWindow,
54962 &_swigt__p_wxWindowCreateEvent,
54963 &_swigt__p_wxWindowDestroyEvent,
54964 &_swigt__p_wxXPMHandler,
54965 &_swigt__p_wxZipFSHandler,
54966 };
54967
54968 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54969 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54970 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54971 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54972 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54973 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54974 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54975 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54976 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54977 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54978 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54979 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54980 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54981 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54982 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}};
54983 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54984 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}};
54985 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54986 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}};
54987 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54988 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54989 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
54990 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54991 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54992 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
54993 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54994 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}};
54995 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54996 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54997 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54998 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54999 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55000 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55001 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55002 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55003 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55004 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
55005 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55006 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55007 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}};
55008 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55009 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55010 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}};
55011 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}};
55012 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55013 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55014 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55015 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55016 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55017 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55018 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55019 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55020 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}};
55021 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55022 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}};
55023 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55024 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55025 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55026 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}};
55027 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55028 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55029 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55030 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55031 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55032 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55033 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55034 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}};
55035 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55036 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55037 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55038 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55039 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55040 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55041 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55042 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55043 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55044 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55045 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55046 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55047 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55048 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55049 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55050 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55051 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
55052 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55053 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55054 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55055 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55056 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55057 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55058 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55059 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55060 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55061 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55062 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55063 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55064 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55065 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55066 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55067 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55068 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55069 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55070 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55071 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55072 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55073 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55074 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55075 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55076 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55077 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55078 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55079 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55080 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55081 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55082 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55083 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}};
55084 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}};
55085 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55086 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55087 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55088 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55089 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55090 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55091 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55092 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}};
55093 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55094 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}};
55095 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55096 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55097 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55098 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55099
55100 static swig_cast_info *swig_cast_initial[] = {
55101 _swigc__p_buffer,
55102 _swigc__p_char,
55103 _swigc__p_form_ops_t,
55104 _swigc__p_int,
55105 _swigc__p_long,
55106 _swigc__p_unsigned_char,
55107 _swigc__p_unsigned_int,
55108 _swigc__p_unsigned_long,
55109 _swigc__p_wxANIHandler,
55110 _swigc__p_wxAcceleratorEntry,
55111 _swigc__p_wxAcceleratorTable,
55112 _swigc__p_wxActivateEvent,
55113 _swigc__p_wxAppTraits,
55114 _swigc__p_wxArrayString,
55115 _swigc__p_wxBMPHandler,
55116 _swigc__p_wxBitmap,
55117 _swigc__p_wxBoxSizer,
55118 _swigc__p_wxButton,
55119 _swigc__p_wxCURHandler,
55120 _swigc__p_wxCaret,
55121 _swigc__p_wxChildFocusEvent,
55122 _swigc__p_wxClipboardTextEvent,
55123 _swigc__p_wxCloseEvent,
55124 _swigc__p_wxColour,
55125 _swigc__p_wxCommandEvent,
55126 _swigc__p_wxContextMenuEvent,
55127 _swigc__p_wxControl,
55128 _swigc__p_wxControlWithItems,
55129 _swigc__p_wxCursor,
55130 _swigc__p_wxDC,
55131 _swigc__p_wxDateEvent,
55132 _swigc__p_wxDateTime,
55133 _swigc__p_wxDisplayChangedEvent,
55134 _swigc__p_wxDropFilesEvent,
55135 _swigc__p_wxDuplexMode,
55136 _swigc__p_wxEraseEvent,
55137 _swigc__p_wxEvent,
55138 _swigc__p_wxEventLoop,
55139 _swigc__p_wxEventLoopActivator,
55140 _swigc__p_wxEvtHandler,
55141 _swigc__p_wxFSFile,
55142 _swigc__p_wxFileSystem,
55143 _swigc__p_wxFileSystemHandler,
55144 _swigc__p_wxFlexGridSizer,
55145 _swigc__p_wxFocusEvent,
55146 _swigc__p_wxFont,
55147 _swigc__p_wxFrame,
55148 _swigc__p_wxGBPosition,
55149 _swigc__p_wxGBSizerItem,
55150 _swigc__p_wxGBSpan,
55151 _swigc__p_wxGIFHandler,
55152 _swigc__p_wxGridBagSizer,
55153 _swigc__p_wxGridSizer,
55154 _swigc__p_wxHelpEvent__Origin,
55155 _swigc__p_wxICOHandler,
55156 _swigc__p_wxIconizeEvent,
55157 _swigc__p_wxIdleEvent,
55158 _swigc__p_wxImage,
55159 _swigc__p_wxImageHandler,
55160 _swigc__p_wxImageHistogram,
55161 _swigc__p_wxImage_HSVValue,
55162 _swigc__p_wxImage_RGBValue,
55163 _swigc__p_wxIndividualLayoutConstraint,
55164 _swigc__p_wxInitDialogEvent,
55165 _swigc__p_wxInputStream,
55166 _swigc__p_wxInternetFSHandler,
55167 _swigc__p_wxItemContainer,
55168 _swigc__p_wxJPEGHandler,
55169 _swigc__p_wxKeyEvent,
55170 _swigc__p_wxLayoutConstraints,
55171 _swigc__p_wxMaximizeEvent,
55172 _swigc__p_wxMemoryFSHandler,
55173 _swigc__p_wxMenu,
55174 _swigc__p_wxMenuBar,
55175 _swigc__p_wxMenuBarBase,
55176 _swigc__p_wxMenuEvent,
55177 _swigc__p_wxMenuItem,
55178 _swigc__p_wxMouseCaptureChangedEvent,
55179 _swigc__p_wxMouseEvent,
55180 _swigc__p_wxMoveEvent,
55181 _swigc__p_wxNavigationKeyEvent,
55182 _swigc__p_wxNcPaintEvent,
55183 _swigc__p_wxNotifyEvent,
55184 _swigc__p_wxObject,
55185 _swigc__p_wxOutputStream,
55186 _swigc__p_wxPCXHandler,
55187 _swigc__p_wxPNGHandler,
55188 _swigc__p_wxPNMHandler,
55189 _swigc__p_wxPaintEvent,
55190 _swigc__p_wxPaletteChangedEvent,
55191 _swigc__p_wxPaperSize,
55192 _swigc__p_wxPoint,
55193 _swigc__p_wxPoint2D,
55194 _swigc__p_wxPropagateOnce,
55195 _swigc__p_wxPropagationDisabler,
55196 _swigc__p_wxPyApp,
55197 _swigc__p_wxPyCommandEvent,
55198 _swigc__p_wxPyDropTarget,
55199 _swigc__p_wxPyEvent,
55200 _swigc__p_wxPyFileSystemHandler,
55201 _swigc__p_wxPyImageHandler,
55202 _swigc__p_wxPyInputStream,
55203 _swigc__p_wxPySizer,
55204 _swigc__p_wxPyValidator,
55205 _swigc__p_wxQuantize,
55206 _swigc__p_wxQueryNewPaletteEvent,
55207 _swigc__p_wxRealPoint,
55208 _swigc__p_wxRect,
55209 _swigc__p_wxRegion,
55210 _swigc__p_wxScrollEvent,
55211 _swigc__p_wxScrollWinEvent,
55212 _swigc__p_wxSetCursorEvent,
55213 _swigc__p_wxShowEvent,
55214 _swigc__p_wxSize,
55215 _swigc__p_wxSizeEvent,
55216 _swigc__p_wxSizer,
55217 _swigc__p_wxSizerItem,
55218 _swigc__p_wxStaticBox,
55219 _swigc__p_wxStaticBoxSizer,
55220 _swigc__p_wxStdDialogButtonSizer,
55221 _swigc__p_wxSysColourChangedEvent,
55222 _swigc__p_wxTIFFHandler,
55223 _swigc__p_wxToolTip,
55224 _swigc__p_wxUpdateUIEvent,
55225 _swigc__p_wxValidator,
55226 _swigc__p_wxVisualAttributes,
55227 _swigc__p_wxWindow,
55228 _swigc__p_wxWindowCreateEvent,
55229 _swigc__p_wxWindowDestroyEvent,
55230 _swigc__p_wxXPMHandler,
55231 _swigc__p_wxZipFSHandler,
55232 };
55233
55234
55235 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55236
55237 static swig_const_info swig_const_table[] = {
55238 {0, 0, 0, 0.0, 0, 0}};
55239
55240 #ifdef __cplusplus
55241 }
55242 #endif
55243 /* -----------------------------------------------------------------------------
55244 * Type initialization:
55245 * This problem is tough by the requirement that no dynamic
55246 * memory is used. Also, since swig_type_info structures store pointers to
55247 * swig_cast_info structures and swig_cast_info structures store pointers back
55248 * to swig_type_info structures, we need some lookup code at initialization.
55249 * The idea is that swig generates all the structures that are needed.
55250 * The runtime then collects these partially filled structures.
55251 * The SWIG_InitializeModule function takes these initial arrays out of
55252 * swig_module, and does all the lookup, filling in the swig_module.types
55253 * array with the correct data and linking the correct swig_cast_info
55254 * structures together.
55255 *
55256 * The generated swig_type_info structures are assigned staticly to an initial
55257 * array. We just loop though that array, and handle each type individually.
55258 * First we lookup if this type has been already loaded, and if so, use the
55259 * loaded structure instead of the generated one. Then we have to fill in the
55260 * cast linked list. The cast data is initially stored in something like a
55261 * two-dimensional array. Each row corresponds to a type (there are the same
55262 * number of rows as there are in the swig_type_initial array). Each entry in
55263 * a column is one of the swig_cast_info structures for that type.
55264 * The cast_initial array is actually an array of arrays, because each row has
55265 * a variable number of columns. So to actually build the cast linked list,
55266 * we find the array of casts associated with the type, and loop through it
55267 * adding the casts to the list. The one last trick we need to do is making
55268 * sure the type pointer in the swig_cast_info struct is correct.
55269 *
55270 * First off, we lookup the cast->type name to see if it is already loaded.
55271 * There are three cases to handle:
55272 * 1) If the cast->type has already been loaded AND the type we are adding
55273 * casting info to has not been loaded (it is in this module), THEN we
55274 * replace the cast->type pointer with the type pointer that has already
55275 * been loaded.
55276 * 2) If BOTH types (the one we are adding casting info to, and the
55277 * cast->type) are loaded, THEN the cast info has already been loaded by
55278 * the previous module so we just ignore it.
55279 * 3) Finally, if cast->type has not already been loaded, then we add that
55280 * swig_cast_info to the linked list (because the cast->type) pointer will
55281 * be correct.
55282 * ----------------------------------------------------------------------------- */
55283
55284 #ifdef __cplusplus
55285 extern "C" {
55286 #if 0
55287 } /* c-mode */
55288 #endif
55289 #endif
55290
55291 #if 0
55292 #define SWIGRUNTIME_DEBUG
55293 #endif
55294
55295 SWIGRUNTIME void
55296 SWIG_InitializeModule(void *clientdata) {
55297 size_t i;
55298 swig_module_info *module_head;
55299 static int init_run = 0;
55300
55301 clientdata = clientdata;
55302
55303 if (init_run) return;
55304 init_run = 1;
55305
55306 /* Initialize the swig_module */
55307 swig_module.type_initial = swig_type_initial;
55308 swig_module.cast_initial = swig_cast_initial;
55309
55310 /* Try and load any already created modules */
55311 module_head = SWIG_GetModule(clientdata);
55312 if (module_head) {
55313 swig_module.next = module_head->next;
55314 module_head->next = &swig_module;
55315 } else {
55316 /* This is the first module loaded */
55317 swig_module.next = &swig_module;
55318 SWIG_SetModule(clientdata, &swig_module);
55319 }
55320
55321 /* Now work on filling in swig_module.types */
55322 #ifdef SWIGRUNTIME_DEBUG
55323 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55324 #endif
55325 for (i = 0; i < swig_module.size; ++i) {
55326 swig_type_info *type = 0;
55327 swig_type_info *ret;
55328 swig_cast_info *cast;
55329
55330 #ifdef SWIGRUNTIME_DEBUG
55331 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55332 #endif
55333
55334 /* if there is another module already loaded */
55335 if (swig_module.next != &swig_module) {
55336 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55337 }
55338 if (type) {
55339 /* Overwrite clientdata field */
55340 #ifdef SWIGRUNTIME_DEBUG
55341 printf("SWIG_InitializeModule: found type %s\n", type->name);
55342 #endif
55343 if (swig_module.type_initial[i]->clientdata) {
55344 type->clientdata = swig_module.type_initial[i]->clientdata;
55345 #ifdef SWIGRUNTIME_DEBUG
55346 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55347 #endif
55348 }
55349 } else {
55350 type = swig_module.type_initial[i];
55351 }
55352
55353 /* Insert casting types */
55354 cast = swig_module.cast_initial[i];
55355 while (cast->type) {
55356 /* Don't need to add information already in the list */
55357 ret = 0;
55358 #ifdef SWIGRUNTIME_DEBUG
55359 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55360 #endif
55361 if (swig_module.next != &swig_module) {
55362 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55363 #ifdef SWIGRUNTIME_DEBUG
55364 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55365 #endif
55366 }
55367 if (ret) {
55368 if (type == swig_module.type_initial[i]) {
55369 #ifdef SWIGRUNTIME_DEBUG
55370 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55371 #endif
55372 cast->type = ret;
55373 ret = 0;
55374 } else {
55375 /* Check for casting already in the list */
55376 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55377 #ifdef SWIGRUNTIME_DEBUG
55378 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55379 #endif
55380 if (!ocast) ret = 0;
55381 }
55382 }
55383
55384 if (!ret) {
55385 #ifdef SWIGRUNTIME_DEBUG
55386 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55387 #endif
55388 if (type->cast) {
55389 type->cast->prev = cast;
55390 cast->next = type->cast;
55391 }
55392 type->cast = cast;
55393 }
55394 cast++;
55395 }
55396 /* Set entry in modules->types array equal to the type */
55397 swig_module.types[i] = type;
55398 }
55399 swig_module.types[i] = 0;
55400
55401 #ifdef SWIGRUNTIME_DEBUG
55402 printf("**** SWIG_InitializeModule: Cast List ******\n");
55403 for (i = 0; i < swig_module.size; ++i) {
55404 int j = 0;
55405 swig_cast_info *cast = swig_module.cast_initial[i];
55406 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55407 while (cast->type) {
55408 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55409 cast++;
55410 ++j;
55411 }
55412 printf("---- Total casts: %d\n",j);
55413 }
55414 printf("**** SWIG_InitializeModule: Cast List ******\n");
55415 #endif
55416 }
55417
55418 /* This function will propagate the clientdata field of type to
55419 * any new swig_type_info structures that have been added into the list
55420 * of equivalent types. It is like calling
55421 * SWIG_TypeClientData(type, clientdata) a second time.
55422 */
55423 SWIGRUNTIME void
55424 SWIG_PropagateClientData(void) {
55425 size_t i;
55426 swig_cast_info *equiv;
55427 static int init_run = 0;
55428
55429 if (init_run) return;
55430 init_run = 1;
55431
55432 for (i = 0; i < swig_module.size; i++) {
55433 if (swig_module.types[i]->clientdata) {
55434 equiv = swig_module.types[i]->cast;
55435 while (equiv) {
55436 if (!equiv->converter) {
55437 if (equiv->type && !equiv->type->clientdata)
55438 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55439 }
55440 equiv = equiv->next;
55441 }
55442 }
55443 }
55444 }
55445
55446 #ifdef __cplusplus
55447 #if 0
55448 {
55449 /* c-mode */
55450 #endif
55451 }
55452 #endif
55453
55454
55455
55456 #ifdef __cplusplus
55457 extern "C" {
55458 #endif
55459
55460 /* Python-specific SWIG API */
55461 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55462 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55463 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55464
55465 /* -----------------------------------------------------------------------------
55466 * global variable support code.
55467 * ----------------------------------------------------------------------------- */
55468
55469 typedef struct swig_globalvar {
55470 char *name; /* Name of global variable */
55471 PyObject *(*get_attr)(void); /* Return the current value */
55472 int (*set_attr)(PyObject *); /* Set the value */
55473 struct swig_globalvar *next;
55474 } swig_globalvar;
55475
55476 typedef struct swig_varlinkobject {
55477 PyObject_HEAD
55478 swig_globalvar *vars;
55479 } swig_varlinkobject;
55480
55481 SWIGINTERN PyObject *
55482 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55483 return PyString_FromString("<Swig global variables>");
55484 }
55485
55486 SWIGINTERN PyObject *
55487 swig_varlink_str(swig_varlinkobject *v) {
55488 PyObject *str = PyString_FromString("(");
55489 swig_globalvar *var;
55490 for (var = v->vars; var; var=var->next) {
55491 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55492 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55493 }
55494 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55495 return str;
55496 }
55497
55498 SWIGINTERN int
55499 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55500 PyObject *str = swig_varlink_str(v);
55501 fprintf(fp,"Swig global variables ");
55502 fprintf(fp,"%s\n", PyString_AsString(str));
55503 Py_DECREF(str);
55504 return 0;
55505 }
55506
55507 SWIGINTERN void
55508 swig_varlink_dealloc(swig_varlinkobject *v) {
55509 swig_globalvar *var = v->vars;
55510 while (var) {
55511 swig_globalvar *n = var->next;
55512 free(var->name);
55513 free(var);
55514 var = n;
55515 }
55516 }
55517
55518 SWIGINTERN PyObject *
55519 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55520 PyObject *res = NULL;
55521 swig_globalvar *var = v->vars;
55522 while (var) {
55523 if (strcmp(var->name,n) == 0) {
55524 res = (*var->get_attr)();
55525 break;
55526 }
55527 var = var->next;
55528 }
55529 if (res == NULL && !PyErr_Occurred()) {
55530 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55531 }
55532 return res;
55533 }
55534
55535 SWIGINTERN int
55536 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55537 int res = 1;
55538 swig_globalvar *var = v->vars;
55539 while (var) {
55540 if (strcmp(var->name,n) == 0) {
55541 res = (*var->set_attr)(p);
55542 break;
55543 }
55544 var = var->next;
55545 }
55546 if (res == 1 && !PyErr_Occurred()) {
55547 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55548 }
55549 return res;
55550 }
55551
55552 SWIGINTERN PyTypeObject*
55553 swig_varlink_type(void) {
55554 static char varlink__doc__[] = "Swig var link object";
55555 static PyTypeObject varlink_type;
55556 static int type_init = 0;
55557 if (!type_init) {
55558 const PyTypeObject tmp
55559 = {
55560 PyObject_HEAD_INIT(NULL)
55561 0, /* Number of items in variable part (ob_size) */
55562 (char *)"swigvarlink", /* Type name (tp_name) */
55563 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55564 0, /* Itemsize (tp_itemsize) */
55565 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55566 (printfunc) swig_varlink_print, /* Print (tp_print) */
55567 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55568 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55569 0, /* tp_compare */
55570 (reprfunc) swig_varlink_repr, /* tp_repr */
55571 0, /* tp_as_number */
55572 0, /* tp_as_sequence */
55573 0, /* tp_as_mapping */
55574 0, /* tp_hash */
55575 0, /* tp_call */
55576 (reprfunc)swig_varlink_str, /* tp_str */
55577 0, /* tp_getattro */
55578 0, /* tp_setattro */
55579 0, /* tp_as_buffer */
55580 0, /* tp_flags */
55581 varlink__doc__, /* tp_doc */
55582 0, /* tp_traverse */
55583 0, /* tp_clear */
55584 0, /* tp_richcompare */
55585 0, /* tp_weaklistoffset */
55586 #if PY_VERSION_HEX >= 0x02020000
55587 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55588 #endif
55589 #if PY_VERSION_HEX >= 0x02030000
55590 0, /* tp_del */
55591 #endif
55592 #ifdef COUNT_ALLOCS
55593 0,0,0,0 /* tp_alloc -> tp_next */
55594 #endif
55595 };
55596 varlink_type = tmp;
55597 varlink_type.ob_type = &PyType_Type;
55598 type_init = 1;
55599 }
55600 return &varlink_type;
55601 }
55602
55603 /* Create a variable linking object for use later */
55604 SWIGINTERN PyObject *
55605 SWIG_Python_newvarlink(void) {
55606 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55607 if (result) {
55608 result->vars = 0;
55609 }
55610 return ((PyObject*) result);
55611 }
55612
55613 SWIGINTERN void
55614 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55615 swig_varlinkobject *v = (swig_varlinkobject *) p;
55616 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55617 if (gv) {
55618 size_t size = strlen(name)+1;
55619 gv->name = (char *)malloc(size);
55620 if (gv->name) {
55621 strncpy(gv->name,name,size);
55622 gv->get_attr = get_attr;
55623 gv->set_attr = set_attr;
55624 gv->next = v->vars;
55625 }
55626 }
55627 v->vars = gv;
55628 }
55629
55630 SWIGINTERN PyObject *
55631 SWIG_globals() {
55632 static PyObject *_SWIG_globals = 0;
55633 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55634 return _SWIG_globals;
55635 }
55636
55637 /* -----------------------------------------------------------------------------
55638 * constants/methods manipulation
55639 * ----------------------------------------------------------------------------- */
55640
55641 /* Install Constants */
55642 SWIGINTERN void
55643 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55644 PyObject *obj = 0;
55645 size_t i;
55646 for (i = 0; constants[i].type; ++i) {
55647 switch(constants[i].type) {
55648 case SWIG_PY_POINTER:
55649 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55650 break;
55651 case SWIG_PY_BINARY:
55652 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55653 break;
55654 default:
55655 obj = 0;
55656 break;
55657 }
55658 if (obj) {
55659 PyDict_SetItemString(d, constants[i].name, obj);
55660 Py_DECREF(obj);
55661 }
55662 }
55663 }
55664
55665 /* -----------------------------------------------------------------------------*/
55666 /* Fix SwigMethods to carry the callback ptrs when needed */
55667 /* -----------------------------------------------------------------------------*/
55668
55669 SWIGINTERN void
55670 SWIG_Python_FixMethods(PyMethodDef *methods,
55671 swig_const_info *const_table,
55672 swig_type_info **types,
55673 swig_type_info **types_initial) {
55674 size_t i;
55675 for (i = 0; methods[i].ml_name; ++i) {
55676 char *c = methods[i].ml_doc;
55677 if (c && (c = strstr(c, "swig_ptr: "))) {
55678 int j;
55679 swig_const_info *ci = 0;
55680 char *name = c + 10;
55681 for (j = 0; const_table[j].type; ++j) {
55682 if (strncmp(const_table[j].name, name,
55683 strlen(const_table[j].name)) == 0) {
55684 ci = &(const_table[j]);
55685 break;
55686 }
55687 }
55688 if (ci) {
55689 size_t shift = (ci->ptype) - types;
55690 swig_type_info *ty = types_initial[shift];
55691 size_t ldoc = (c - methods[i].ml_doc);
55692 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55693 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55694 if (ndoc) {
55695 char *buff = ndoc;
55696 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55697 if (ptr) {
55698 strncpy(buff, methods[i].ml_doc, ldoc);
55699 buff += ldoc;
55700 strncpy(buff, "swig_ptr: ", 10);
55701 buff += 10;
55702 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55703 methods[i].ml_doc = ndoc;
55704 }
55705 }
55706 }
55707 }
55708 }
55709 }
55710
55711 #ifdef __cplusplus
55712 }
55713 #endif
55714
55715 /* -----------------------------------------------------------------------------*
55716 * Partial Init method
55717 * -----------------------------------------------------------------------------*/
55718
55719 #ifdef __cplusplus
55720 extern "C"
55721 #endif
55722 SWIGEXPORT void SWIG_init(void) {
55723 PyObject *m, *d;
55724
55725 /* Fix SwigMethods to carry the callback ptrs when needed */
55726 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55727
55728 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55729 d = PyModule_GetDict(m);
55730
55731 SWIG_InitializeModule(0);
55732 SWIG_InstallConstants(d,swig_const_table);
55733
55734
55735
55736 #ifndef wxPyUSE_EXPORT
55737 // Make our API structure a CObject so other modules can import it
55738 // from this module.
55739 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55740 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55741 Py_XDECREF(cobj);
55742 #endif
55743
55744 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55745 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55746 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55747 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55748 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55749 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55750 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55751 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55752 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55753 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55754 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55755 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55756 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55757 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55758 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55759 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55760 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55761 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55762 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55763 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55764 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55765 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55766 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55767 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55768 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55769 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55770 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55771 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55772 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55773 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55774 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55775 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55776 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55777 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55778 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55779 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55780 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55781 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55782 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55783 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55784 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55785 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55786 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55787 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55788 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55789 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55790 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55791 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55792 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55793 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55794 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55795 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55796 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55797 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55798 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55799 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55800 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55801 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55802 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55803 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55804 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55805 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55806 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55807 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55808 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55809 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55810 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55811 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55812 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55813 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55814 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55815 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55816 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55817 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55818 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55819 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55820 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55821 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55822 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55823 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55824 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55825 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55826 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55827 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55828 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55829 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55830 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55831 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55832 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55833 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55834 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55835 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55836 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55837 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55838 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55839 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55840 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55841 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55842 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55843 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55844 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55845 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55846 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55847 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55848 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55849 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55850 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55851 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55852 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55853 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55854 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55855 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55856 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55857 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55858 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55859 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55860 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55861 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55862 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55863 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55864 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55865 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55866 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55867 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55868 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55869 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55870 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55871 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55872 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55873 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55874 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55875 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55876 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55877 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55878 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55879 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55880 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55881 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55882 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55883 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55884 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55885 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55886 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55887 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55888 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55889 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55890 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55891 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55892 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55893 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55894 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55895 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55896 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55897 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55898 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55899 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55900 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55901 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55902 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55903 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55904 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55905 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55906 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55907 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55908 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55909 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55910 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55911 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55912 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55913 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55914 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55915 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55916 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55917 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55918 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55919 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55920 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55921 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55922 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55923 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55924 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55925 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55926 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55927 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55928 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55929 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55930 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55931 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55932 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55933 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55934 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55935 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55936 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55937 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55938 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55939 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55940 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55941 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55942 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55943 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55944 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55945 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55946 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55947 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55948 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55949 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55950 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55951 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55952 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55953 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55954 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55955 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55956 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55957 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55958 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55959 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55960 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55961 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55962 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55963 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55964 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55965 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55966 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55967 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55968 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55969 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55970 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55971 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55972 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55973 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55974 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55975 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55976 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55977 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55978 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55979 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55980 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55981 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55982 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55983 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55984 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55985 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55986 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55987 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55988 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55989 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55990 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55991 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55992 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55993 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55994 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55995 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55996 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55997 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55998 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55999 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56000 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56001 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56002 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56003 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56004 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56005 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56006 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56007 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56008 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56009 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56010 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56011 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56012 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56013 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56014 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56015 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56016 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56017 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56018 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56019 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56020 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56021 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56022 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56023 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56024 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56025 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56026 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56027 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56028 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56029 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56030 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56031 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56032 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56033 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56034 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56035 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56036 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56037 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56038 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56039 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56040 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56041 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56042 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56043 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56044 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56045 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56046 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56047 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56048 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56049 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56050 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56051 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56052 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56053 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56054 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56055 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56056 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56057 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56058 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56059 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56060 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56061 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56062 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56063 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56064 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56065 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56066 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56067 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56068 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56069 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56070 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56071 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56072 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56073 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56074 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56075 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56076 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56077 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56078 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56079 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56080 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56081 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56082 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56083 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56084 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56085 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56086 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56087 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56088 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56089 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56090 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56091 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56092 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56093 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56094 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56095 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56096 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56097 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56098 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56099 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56100 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56101 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56102 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56103 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56104 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56105 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56106 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56107 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56108 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56109 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56110 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56111 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56112 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56113 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56114 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56115 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56116 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56117 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56118 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56119 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56120 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56121 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56122 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56123 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56124 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56125 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56126 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56127 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56128 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56129 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56130 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56131 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56132 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56133 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56134 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56135 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56136 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56137 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56138 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56139 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56140 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56141 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56142 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56143 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56144 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56145 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56146 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56147 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56148 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56149 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56150 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56151 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56152 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56153 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56154 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56155 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56156 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56157 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56158 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56159 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56160 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56161 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56162 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56163 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56164 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56165 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56166 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56167 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56168 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56169 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56170 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56171 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56172 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56173 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56174 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56175 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56176 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56177 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56178 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56179 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56180 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56181 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56182 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56183 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56184 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56185 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56186 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56187 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56188 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56189 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56190 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56191 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56192 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56193 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56194 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56195 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56196 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56197 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56198 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56199 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56200 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56201 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56202 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56203 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56204 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56205 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56206 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56207 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56208 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56209 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56210 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56211 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56212 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56213 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56214 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56215 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56216 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56217 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56218 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56219 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56220 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56221 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56222 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56223 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56224 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56225 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56226 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56227 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56228 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56229 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56230 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56231 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56232 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56233 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56234 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56235 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56236 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56237 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56238 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56239 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56240 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56241 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56242 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56243 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56244 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56245 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56246 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56247 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56248 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56249 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56250 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56251 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56252 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56253 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56254 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56255 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56256 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56257 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56258 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56259 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56260 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56261 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56262 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56263 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56264 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56265 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56266 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56267 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56268 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56269 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56270 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56271 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56272 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56273 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56274 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56275 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56276 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56277 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56278 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56279 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56280 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56281 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56282 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56283 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56284 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56285 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56286 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56287 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56288 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56289 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56290 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56291 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56292 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56293 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56294 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56295 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56296 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56297 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56298 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56299 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56300 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56301 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56302 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56303 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56304 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56305 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56306 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56307 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56308 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56309 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56310 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56311 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56312 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56313 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56314 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56315 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56316 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56317 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56318 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56319 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56320 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56321 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56322 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56323 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56324 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56325 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56326 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56327 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56328 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56329 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56330 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56331 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56332 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56333 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56334 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56335 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56336 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56337 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56338 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56339 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56340 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56341 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56342 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56343 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56344 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56345 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56346 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56347 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56348 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56349 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56350 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56351 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56352 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56353 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56354 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56355 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56356 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56357 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56358 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56359 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56360 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56361 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56362 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56363 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56364 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56365 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56366 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56367 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56368 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56369 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56370 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56371 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56372 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56373 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56374 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56375 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56376 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56377 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56378 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56379 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56380 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56381 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56382 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56383 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56384 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56385 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56386 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56387 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56388 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56389 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56390 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56391 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56392 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56393 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56394 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56395 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56396 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56397 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56398 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56399 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56400 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56401 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56402 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56403 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56404 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56405 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56406 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56407
56408 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56409
56410
56411 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56412
56413 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56414 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56415 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56416 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56417 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56418 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56419 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56420 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56421 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56422 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56423 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56424 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56425 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56426 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56427 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56428 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56429 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56430 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56431 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56432 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56433 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56434 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56435 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56436 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56437 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56438 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56439 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56440 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56441 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56442 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56443 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56444 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56445 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56446 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56447 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56448 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56449 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56450 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56451 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56452 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56453 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56454 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56455 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56456 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56457 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56458 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56459 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56460 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56461 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56462 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56463 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56464 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56465 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56466 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56467 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56468 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56469 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56470 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56471 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56472 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56473 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56474 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56475 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56476 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56477 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56478 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56479 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56480 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56481 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56482 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56483 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56484 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56485 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56486 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56487 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56488 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56489 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56490 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56491 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56492 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56493 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56494 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56495 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56496 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56497 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56498 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56499 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56500 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56501 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56502 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56503 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56504 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56505 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56506 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56507 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56508 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56509 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56510 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56511 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56512 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56513 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56514 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56515 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56516 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56517 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56518 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56519 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56520 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56521 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56522 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56523 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56524 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56525 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56526 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56527 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56528 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56529 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56530 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56531 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56532 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56533 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56534 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56535 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56536 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56537 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56538 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56539 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56540 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56541 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56542 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56543 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56544 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56545 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56546 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56547 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56548 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56549 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56550 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56551 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56552 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56553 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56554 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56555 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56556 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56557 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56558 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56559 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56560 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56561 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56562 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56563 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56564 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56565 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56566 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56567 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56568 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56569 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56570 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56571 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56572 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56573 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56574 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56575 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56576 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56577 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56578 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56579 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56580 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56581 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56582 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56583 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56584 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56585 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56586 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56587 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56588 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56589 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56590 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56591 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56592 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56593 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56594 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56595 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56596 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56597 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56598 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56599 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56600 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56601 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56602 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56603 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56604 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56605 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56606 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56607 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56608 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56609 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56610 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56611 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56612 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56613 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56614 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56615 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56616 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56617 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56618 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56619
56620 // Initialize threading, some globals and such
56621 __wxPyPreStart(d);
56622
56623
56624 // Although these are defined in __version__ they need to be here too so
56625 // that an assert can be done to ensure that the wxPython and the wxWindows
56626 // versions match.
56627 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56628 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56629 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56630
56631 }
56632
wxWidgets (Impactor)