]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
2484 #define SWIGTYPE_p_wxColour swig_types[22]
2485 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
2486 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
2487 #define SWIGTYPE_p_wxControl swig_types[25]
2488 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
2489 #define SWIGTYPE_p_wxCursor swig_types[27]
2490 #define SWIGTYPE_p_wxDC swig_types[28]
2491 #define SWIGTYPE_p_wxDateEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDateTime swig_types[30]
2493 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
2494 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
2496 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
2497 #define SWIGTYPE_p_wxEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEventLoop swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
2501 #define SWIGTYPE_p_wxFSFile swig_types[39]
2502 #define SWIGTYPE_p_wxFileSystem swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
2504 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2505 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2506 #define SWIGTYPE_p_wxFont swig_types[44]
2507 #define SWIGTYPE_p_wxFrame swig_types[45]
2508 #define SWIGTYPE_p_wxGBPosition swig_types[46]
2509 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2510 #define SWIGTYPE_p_wxGBSpan swig_types[48]
2511 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
2512 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2513 #define SWIGTYPE_p_wxGridSizer swig_types[51]
2514 #define SWIGTYPE_p_wxICOHandler swig_types[52]
2515 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
2516 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
2517 #define SWIGTYPE_p_wxImage swig_types[55]
2518 #define SWIGTYPE_p_wxImageHandler swig_types[56]
2519 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
2520 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
2521 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
2522 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
2523 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
2524 #define SWIGTYPE_p_wxInputStream swig_types[62]
2525 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
2526 #define SWIGTYPE_p_wxItemContainer swig_types[64]
2527 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
2528 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
2529 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
2530 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
2532 #define SWIGTYPE_p_wxMenu swig_types[70]
2533 #define SWIGTYPE_p_wxMenuBar swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
2535 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
2536 #define SWIGTYPE_p_wxMenuItem swig_types[74]
2537 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
2540 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxObject swig_types[81]
2544 #define SWIGTYPE_p_wxOutputStream swig_types[82]
2545 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
2546 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
2549 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaperSize swig_types[88]
2551 #define SWIGTYPE_p_wxPoint swig_types[89]
2552 #define SWIGTYPE_p_wxPoint2D swig_types[90]
2553 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
2554 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
2555 #define SWIGTYPE_p_wxPyApp swig_types[93]
2556 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
2557 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
2558 #define SWIGTYPE_p_wxPyEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
2560 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
2562 #define SWIGTYPE_p_wxPySizer swig_types[100]
2563 #define SWIGTYPE_p_wxPyValidator swig_types[101]
2564 #define SWIGTYPE_p_wxQuantize swig_types[102]
2565 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
2566 #define SWIGTYPE_p_wxRealPoint swig_types[104]
2567 #define SWIGTYPE_p_wxRect swig_types[105]
2568 #define SWIGTYPE_p_wxRegion swig_types[106]
2569 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
2570 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
2571 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
2572 #define SWIGTYPE_p_wxShowEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSize swig_types[111]
2574 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSizer swig_types[113]
2576 #define SWIGTYPE_p_wxSizerItem swig_types[114]
2577 #define SWIGTYPE_p_wxStaticBox swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
2579 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
2580 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
2581 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
2582 #define SWIGTYPE_p_wxToolTip swig_types[120]
2583 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
2584 #define SWIGTYPE_p_wxValidator swig_types[122]
2585 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
2586 #define SWIGTYPE_p_wxWindow swig_types[124]
2587 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
2588 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
2589 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
2590 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
2591 static swig_type_info *swig_types[130];
2592 static swig_module_info swig_module = {swig_types, 129, 0, 0, 0, 0};
2593 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2594 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2595
2596 /* -------- TYPES TABLE (END) -------- */
2597
2598 #if (PY_VERSION_HEX <= 0x02000000)
2599 # if !defined(SWIG_PYTHON_CLASSIC)
2600 # error "This python version requires to use swig with the '-classic' option"
2601 # endif
2602 #endif
2603 #if (PY_VERSION_HEX <= 0x02020000)
2604 # error "This python version requires to use swig with the '-nomodern' option"
2605 #endif
2606 #if (PY_VERSION_HEX <= 0x02020000)
2607 # error "This python version requires to use swig with the '-nomodernargs' option"
2608 #endif
2609 #ifndef METH_O
2610 # error "This python version requires to use swig with the '-nofastunpack' option"
2611 #endif
2612
2613 /*-----------------------------------------------
2614 @(target):= _core_.so
2615 ------------------------------------------------*/
2616 #define SWIG_init init_core_
2617
2618 #define SWIG_name "_core_"
2619
2620 #define SWIGVERSION 0x010329
2621
2622
2623 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2624 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2625
2626
2627 #include <stdexcept>
2628
2629
2630 namespace swig {
2631 class PyObject_ptr {
2632 protected:
2633 PyObject *_obj;
2634
2635 public:
2636 PyObject_ptr() :_obj(0)
2637 {
2638 }
2639
2640 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2641 {
2642 Py_XINCREF(_obj);
2643 }
2644
2645 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2646 {
2647 if (initial_ref) Py_XINCREF(_obj);
2648 }
2649
2650 PyObject_ptr & operator=(const PyObject_ptr& item)
2651 {
2652 Py_XINCREF(item._obj);
2653 Py_XDECREF(_obj);
2654 _obj = item._obj;
2655 return *this;
2656 }
2657
2658 ~PyObject_ptr()
2659 {
2660 Py_XDECREF(_obj);
2661 }
2662
2663 operator PyObject *() const
2664 {
2665 return _obj;
2666 }
2667
2668 PyObject *operator->() const
2669 {
2670 return _obj;
2671 }
2672 };
2673 }
2674
2675
2676 namespace swig {
2677 struct PyObject_var : PyObject_ptr {
2678 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2679
2680 PyObject_var & operator = (PyObject* obj)
2681 {
2682 Py_XDECREF(_obj);
2683 _obj = obj;
2684 return *this;
2685 }
2686 };
2687 }
2688
2689
2690 #include "wx/wxPython/wxPython_int.h"
2691 #include "wx/wxPython/pyclasses.h"
2692
2693
2694 #ifndef wxPyUSE_EXPORT
2695 // Helper functions for dealing with SWIG objects and such. These are
2696 // located here so they know about the SWIG types and functions declared
2697 // in the wrapper code.
2698
2699 #include <wx/hashmap.h>
2700 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2701
2702
2703 // Maintains a hashmap of className to swig_type_info pointers. Given the
2704 // name of a class either looks up the type info in the cache, or scans the
2705 // SWIG tables for it.
2706 extern PyObject* wxPyPtrTypeMap;
2707 static
2708 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2709
2710 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2711
2712 if (typeInfoCache == NULL)
2713 typeInfoCache = new wxPyTypeInfoHashMap;
2714
2715 wxString name(className);
2716 swig_type_info* swigType = (*typeInfoCache)[name];
2717
2718 if (! swigType) {
2719 // it wasn't in the cache, so look it up from SWIG
2720 name.Append(wxT(" *"));
2721 swigType = SWIG_TypeQuery(name.mb_str());
2722
2723 // if it still wasn't found, try looking for a mapped name
2724 if (!swigType) {
2725 PyObject* item;
2726 name = className;
2727
2728 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2729 (char*)(const char*)name.mbc_str())) != NULL) {
2730 name = wxString(PyString_AsString(item), *wxConvCurrent);
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733 }
2734 }
2735 if (swigType) {
2736 // and add it to the map if found
2737 (*typeInfoCache)[className] = swigType;
2738 }
2739 }
2740 return swigType;
2741 }
2742
2743
2744 // Check if a class name is a type known to SWIG
2745 bool wxPyCheckSwigType(const wxChar* className) {
2746
2747 swig_type_info* swigType = wxPyFindSwigType(className);
2748 return swigType != NULL;
2749 }
2750
2751
2752 // Given a pointer to a C++ object and a class name, construct a Python proxy
2753 // object for it.
2754 PyObject* wxPyConstructObject(void* ptr,
2755 const wxChar* className,
2756 int setThisOwn) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2760
2761 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2762 }
2763
2764
2765 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2766 // Ensures that the proxy object is of the specified (or derived) type. If
2767 // not able to perform the conversion then a Python exception is set and the
2768 // error should be handled properly in the caller. Returns True on success.
2769 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2770 const wxChar* className) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2774
2775 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2776 }
2777
2778
2779
2780 // Make a SWIGified pointer object suitable for a .this attribute
2781 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2782
2783 PyObject* robj = NULL;
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2787
2788 robj = PySwigObject_New(ptr, swigType, 0);
2789 return robj;
2790 }
2791
2792
2793 // Python's PyInstance_Check does not return True for instances of new-style
2794 // classes. This should get close enough for both new and old classes but I
2795 // should re-evaluate the need for doing instance checks...
2796 bool wxPyInstance_Check(PyObject* obj) {
2797 return PyObject_HasAttrString(obj, "__class__") != 0;
2798 }
2799
2800
2801 // This one checks if the object is an instance of a SWIG proxy class (it has
2802 // a .this attribute, and the .this attribute is a PySwigObject.)
2803 bool wxPySwigInstance_Check(PyObject* obj) {
2804 static PyObject* this_str = NULL;
2805 if (this_str == NULL)
2806 this_str = PyString_FromString("this");
2807
2808 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2809 if (this_attr) {
2810 bool retval = (PySwigObject_Check(this_attr) != 0);
2811 Py_DECREF(this_attr);
2812 return retval;
2813 }
2814
2815 PyErr_Clear();
2816 return false;
2817 }
2818
2819
2820 // Export a C API in a struct. Other modules will be able to load this from
2821 // the wx._core_ module and will then have safe access to these functions,
2822 // even if they are located in another shared library.
2823 static wxPyCoreAPI API = {
2824
2825 wxPyCheckSwigType,
2826 wxPyConstructObject,
2827 wxPyConvertSwigPtr,
2828 wxPyMakeSwigPtr,
2829
2830 wxPyBeginAllowThreads,
2831 wxPyEndAllowThreads,
2832 wxPyBeginBlockThreads,
2833 wxPyEndBlockThreads,
2834
2835 wxPy_ConvertList,
2836
2837 wxString_in_helper,
2838 Py2wxString,
2839 wx2PyString,
2840
2841 byte_LIST_helper,
2842 int_LIST_helper,
2843 long_LIST_helper,
2844 string_LIST_helper,
2845 wxPoint_LIST_helper,
2846 wxBitmap_LIST_helper,
2847 wxString_LIST_helper,
2848 wxAcceleratorEntry_LIST_helper,
2849
2850 wxSize_helper,
2851 wxPoint_helper,
2852 wxRealPoint_helper,
2853 wxRect_helper,
2854 wxColour_helper,
2855 wxPoint2D_helper,
2856
2857 wxPySimple_typecheck,
2858 wxColour_typecheck,
2859
2860 wxPyCBH_setCallbackInfo,
2861 wxPyCBH_findCallback,
2862 wxPyCBH_callCallback,
2863 wxPyCBH_callCallbackObj,
2864 wxPyCBH_delete,
2865
2866 wxPyMake_wxObject,
2867 wxPyMake_wxSizer,
2868 wxPyPtrTypeMap_Add,
2869 wxPy2int_seq_helper,
2870 wxPy4int_seq_helper,
2871 wxArrayString2PyList_helper,
2872 wxArrayInt2PyList_helper,
2873
2874 wxPyClientData_dtor,
2875 wxPyUserData_dtor,
2876 wxPyOORClientData_dtor,
2877
2878 wxPyCBInputStream_create,
2879 wxPyCBInputStream_copy,
2880
2881 wxPyInstance_Check,
2882 wxPySwigInstance_Check,
2883
2884 wxPyCheckForApp
2885
2886 };
2887
2888 #endif
2889
2890
2891 #if !WXWIN_COMPATIBILITY_2_4
2892 #define wxHIDE_READONLY 0
2893 #endif
2894
2895
2896 #define SWIG_From_long PyInt_FromLong
2897
2898
2899 SWIGINTERNINLINE PyObject *
2900 SWIG_From_int (int value)
2901 {
2902 return SWIG_From_long (value);
2903 }
2904
2905 static const wxString wxPyEmptyString(wxEmptyString);
2906 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2907 return self->GetClassInfo()->GetClassName();
2908 }
2909 SWIGINTERN void wxObject_Destroy(wxObject *self){
2910 delete self;
2911 }
2912
2913 #ifndef __WXMAC__
2914 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2915 #endif
2916
2917
2918 #include <limits.h>
2919 #ifndef LLONG_MIN
2920 # define LLONG_MIN LONG_LONG_MIN
2921 #endif
2922 #ifndef LLONG_MAX
2923 # define LLONG_MAX LONG_LONG_MAX
2924 #endif
2925 #ifndef ULLONG_MAX
2926 # define ULLONG_MAX ULONG_LONG_MAX
2927 #endif
2928
2929
2930 SWIGINTERN int
2931 SWIG_AsVal_long (PyObject* obj, long* val)
2932 {
2933 if (PyNumber_Check(obj)) {
2934 if (val) *val = PyInt_AsLong(obj);
2935 return SWIG_OK;
2936 }
2937 return SWIG_TypeError;
2938 }
2939
2940
2941 SWIGINTERN int
2942 SWIG_AsVal_int (PyObject * obj, int *val)
2943 {
2944 long v;
2945 int res = SWIG_AsVal_long (obj, &v);
2946 if (SWIG_IsOK(res)) {
2947 if ((v < INT_MIN || v > INT_MAX)) {
2948 return SWIG_OverflowError;
2949 } else {
2950 if (val) *val = static_cast< int >(v);
2951 }
2952 }
2953 return res;
2954 }
2955
2956 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2957 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2958 PyObject* tup = PyTuple_New(2);
2959 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2960 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2961 wxPyEndBlockThreads(blocked);
2962 return tup;
2963 }
2964
2965 SWIGINTERN int
2966 SWIG_AsVal_double (PyObject *obj, double* val)
2967 {
2968 if (PyNumber_Check(obj)) {
2969 if (val) *val = PyFloat_AsDouble(obj);
2970 return SWIG_OK;
2971 }
2972 return SWIG_TypeError;
2973 }
2974
2975
2976 #define SWIG_From_double PyFloat_FromDouble
2977
2978 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
2979 self->x = x;
2980 self->y = y;
2981 }
2982 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
2983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2984 PyObject* tup = PyTuple_New(2);
2985 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
2986 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
2987 wxPyEndBlockThreads(blocked);
2988 return tup;
2989 }
2990 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
2991 self->x = x;
2992 self->y = y;
2993 }
2994 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
2995 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2996 PyObject* tup = PyTuple_New(2);
2997 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2998 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2999 wxPyEndBlockThreads(blocked);
3000 return tup;
3001 }
3002 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3003 self->x = x;
3004 self->y = y;
3005 self->width = width;
3006 self->height = height;
3007 }
3008 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3009 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3010 PyObject* tup = PyTuple_New(4);
3011 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3012 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3013 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3014 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3015 wxPyEndBlockThreads(blocked);
3016 return tup;
3017 }
3018
3019 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3020 wxRegion reg1(*r1);
3021 wxRegion reg2(*r2);
3022 wxRect dest(0,0,0,0);
3023 PyObject* obj;
3024
3025 reg1.Intersect(reg2);
3026 dest = reg1.GetBox();
3027
3028 if (dest != wxRect(0,0,0,0)) {
3029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3030 wxRect* newRect = new wxRect(dest);
3031 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3032 wxPyEndBlockThreads(blocked);
3033 return obj;
3034 }
3035 Py_INCREF(Py_None);
3036 return Py_None;
3037 }
3038
3039 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3040 self->m_x = x;
3041 self->m_y = y;
3042 }
3043 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3044 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3045 PyObject* tup = PyTuple_New(2);
3046 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3047 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3048 wxPyEndBlockThreads(blocked);
3049 return tup;
3050 }
3051
3052 #include "wx/wxPython/pyistream.h"
3053
3054 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3055 wxInputStream* wxis = wxPyCBInputStream::create(p);
3056 if (wxis)
3057 return new wxPyInputStream(wxis);
3058 else
3059 return NULL;
3060 }
3061
3062 SWIGINTERN swig_type_info*
3063 SWIG_pchar_descriptor()
3064 {
3065 static int init = 0;
3066 static swig_type_info* info = 0;
3067 if (!init) {
3068 info = SWIG_TypeQuery("_p_char");
3069 init = 1;
3070 }
3071 return info;
3072 }
3073
3074
3075 SWIGINTERNINLINE PyObject *
3076 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3077 {
3078 if (carray) {
3079 if (size > INT_MAX) {
3080 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3081 return pchar_descriptor ?
3082 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3083 } else {
3084 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3085 }
3086 } else {
3087 return SWIG_Py_Void();
3088 }
3089 }
3090
3091
3092 SWIGINTERNINLINE PyObject *
3093 SWIG_From_char (char c)
3094 {
3095 return SWIG_FromCharPtrAndSize(&c,1);
3096 }
3097
3098
3099 SWIGINTERNINLINE PyObject*
3100 SWIG_From_unsigned_SS_long (unsigned long value)
3101 {
3102 return (value > LONG_MAX) ?
3103 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3104 }
3105
3106
3107 SWIGINTERNINLINE PyObject *
3108 SWIG_From_size_t (size_t value)
3109 {
3110 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3111 }
3112
3113
3114 SWIGINTERN int
3115 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3116 {
3117 if (PyString_Check(obj)) {
3118 char *cstr; int len;
3119 PyString_AsStringAndSize(obj, &cstr, &len);
3120 if (cptr) {
3121 if (alloc) {
3122 /*
3123 In python the user should not be able to modify the inner
3124 string representation. To warranty that, if you define
3125 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3126 buffer is always returned.
3127
3128 The default behavior is just to return the pointer value,
3129 so, be careful.
3130 */
3131 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3132 if (*alloc != SWIG_OLDOBJ)
3133 #else
3134 if (*alloc == SWIG_NEWOBJ)
3135 #endif
3136 {
3137 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3138 *alloc = SWIG_NEWOBJ;
3139 }
3140 else {
3141 *cptr = cstr;
3142 *alloc = SWIG_OLDOBJ;
3143 }
3144 } else {
3145 *cptr = PyString_AsString(obj);
3146 }
3147 }
3148 if (psize) *psize = len + 1;
3149 return SWIG_OK;
3150 } else {
3151 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3152 if (pchar_descriptor) {
3153 void* vptr = 0;
3154 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3155 if (cptr) *cptr = (char *) vptr;
3156 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3157 if (alloc) *alloc = SWIG_OLDOBJ;
3158 return SWIG_OK;
3159 }
3160 }
3161 }
3162 return SWIG_TypeError;
3163 }
3164
3165
3166 SWIGINTERN int
3167 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3168 {
3169 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3170 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3171 if (SWIG_IsOK(res)) {
3172 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3173 if (csize <= size) {
3174 if (val) {
3175 if (csize) memcpy(val, cptr, csize*sizeof(char));
3176 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3177 }
3178 if (alloc == SWIG_NEWOBJ) {
3179 delete[] cptr;
3180 res = SWIG_DelNewMask(res);
3181 }
3182 return res;
3183 }
3184 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3185 }
3186 return SWIG_TypeError;
3187 }
3188
3189
3190 SWIGINTERN int
3191 SWIG_AsVal_char (PyObject * obj, char *val)
3192 {
3193 int res = SWIG_AsCharArray(obj, val, 1);
3194 if (!SWIG_IsOK(res)) {
3195 long v;
3196 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3197 if (SWIG_IsOK(res)) {
3198 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3199 if (val) *val = static_cast< char >(v);
3200 } else {
3201 res = SWIG_OverflowError;
3202 }
3203 }
3204 }
3205 return res;
3206 }
3207
3208 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3209 // We use only strings for the streams, not unicode
3210 PyObject* str = PyObject_Str(obj);
3211 if (! str) {
3212 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3213 return;
3214 }
3215 self->Write(PyString_AS_STRING(str),
3216 PyString_GET_SIZE(str));
3217 Py_DECREF(str);
3218 }
3219
3220 #include "wx/wxPython/pyistream.h"
3221
3222
3223 class wxPyFileSystemHandler : public wxFileSystemHandler
3224 {
3225 public:
3226 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3227
3228 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3229 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3230 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3231 DEC_PYCALLBACK_STRING__pure(FindNext);
3232
3233 wxString GetProtocol(const wxString& location) {
3234 return wxFileSystemHandler::GetProtocol(location);
3235 }
3236
3237 wxString GetLeftLocation(const wxString& location) {
3238 return wxFileSystemHandler::GetLeftLocation(location);
3239 }
3240
3241 wxString GetAnchor(const wxString& location) {
3242 return wxFileSystemHandler::GetAnchor(location);
3243 }
3244
3245 wxString GetRightLocation(const wxString& location) {
3246 return wxFileSystemHandler::GetRightLocation(location);
3247 }
3248
3249 wxString GetMimeTypeFromExt(const wxString& location) {
3250 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3251 }
3252
3253 PYPRIVATE;
3254 };
3255
3256
3257 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3258 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3259 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3260 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3261
3262
3263 SWIGINTERN int
3264 SWIG_AsVal_bool (PyObject *obj, bool *val)
3265 {
3266 if (obj == Py_True) {
3267 if (val) *val = true;
3268 return SWIG_OK;
3269 } else if (obj == Py_False) {
3270 if (val) *val = false;
3271 return SWIG_OK;
3272 } else {
3273 long v = 0;
3274 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3275 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3276 return res;
3277 }
3278 }
3279
3280 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3281 wxFileName fname = wxFileSystem::URLToFileName(url);
3282 return fname.GetFullPath();
3283 }
3284
3285 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3286 wxImage& image,
3287 long type) {
3288 wxMemoryFSHandler::AddFile(filename, image, type);
3289 }
3290
3291 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3292 const wxBitmap& bitmap,
3293 long type) {
3294 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3295 }
3296
3297 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3298 PyObject* data) {
3299 if (! PyString_Check(data)) {
3300 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3301 "Expected string object"));
3302 return;
3303 }
3304
3305 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3306 void* ptr = (void*)PyString_AsString(data);
3307 size_t size = PyString_Size(data);
3308 wxPyEndBlockThreads(blocked);
3309
3310 wxMemoryFSHandler::AddFile(filename, ptr, size);
3311 }
3312
3313
3314 #include "wx/wxPython/pyistream.h"
3315
3316
3317 SWIGINTERN int
3318 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3319 {
3320 long v = 0;
3321 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3322 return SWIG_TypeError;
3323 }
3324 else if (val)
3325 *val = (unsigned long)v;
3326 return SWIG_OK;
3327 }
3328
3329
3330 SWIGINTERN int
3331 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3332 {
3333 unsigned long v;
3334 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3335 if (SWIG_IsOK(res)) {
3336 if ((v > UCHAR_MAX)) {
3337 return SWIG_OverflowError;
3338 } else {
3339 if (val) *val = static_cast< unsigned char >(v);
3340 }
3341 }
3342 return res;
3343 }
3344
3345
3346 SWIGINTERNINLINE PyObject *
3347 SWIG_From_unsigned_SS_char (unsigned char value)
3348 {
3349 return SWIG_From_unsigned_SS_long (value);
3350 }
3351
3352 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3353 wxImageHistogramEntry e = (*self)[key];
3354 return e.value;
3355 }
3356 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3357 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3358 wxImageHistogramEntry e = (*self)[key];
3359 return e.value;
3360 }
3361 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3362 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3363 colour.Green(),
3364 colour.Blue());
3365 wxImageHistogramEntry e = (*self)[key];
3366 return e.value;
3367 }
3368
3369 typedef unsigned char* buffer;
3370
3371
3372 // Pull the nested class out to the top level for SWIG's sake
3373 #define wxImage_RGBValue wxImage::RGBValue
3374 #define wxImage_HSVValue wxImage::HSVValue
3375
3376 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3377 if (width > 0 && height > 0)
3378 return new wxImage(width, height, clear);
3379 else
3380 return new wxImage;
3381 }
3382 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3383 return new wxImage(bitmap.ConvertToImage());
3384 }
3385 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3386 if (DATASIZE != width*height*3) {
3387 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3388 return NULL;
3389 }
3390
3391 // Copy the source data so the wxImage can clean it up later
3392 buffer copy = (buffer)malloc(DATASIZE);
3393 if (copy == NULL) {
3394 wxPyBLOCK_THREADS(PyErr_NoMemory());
3395 return NULL;
3396 }
3397 memcpy(copy, data, DATASIZE);
3398 return new wxImage(width, height, copy, false);
3399 }
3400 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3401 if (DATASIZE != width*height*3) {
3402 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3403 return NULL;
3404 }
3405 if (ALPHASIZE != width*height) {
3406 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3407 return NULL;
3408 }
3409
3410 // Copy the source data so the wxImage can clean it up later
3411 buffer dcopy = (buffer)malloc(DATASIZE);
3412 if (dcopy == NULL) {
3413 wxPyBLOCK_THREADS(PyErr_NoMemory());
3414 return NULL;
3415 }
3416 memcpy(dcopy, data, DATASIZE);
3417
3418 buffer acopy = (buffer)malloc(ALPHASIZE);
3419 if (acopy == NULL) {
3420 wxPyBLOCK_THREADS(PyErr_NoMemory());
3421 return NULL;
3422 }
3423 memcpy(acopy, alpha, ALPHASIZE);
3424
3425 return new wxImage(width, height, dcopy, acopy, false);
3426 }
3427 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3428 wxSize size(self->GetWidth(), self->GetHeight());
3429 return size;
3430 }
3431 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3432 buffer data = self->GetData();
3433 int len = self->GetWidth() * self->GetHeight() * 3;
3434 PyObject* rv;
3435 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3436 return rv;
3437 }
3438 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3439 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3440 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3441 return;
3442 }
3443 buffer copy = (buffer)malloc(DATASIZE);
3444 if (copy == NULL) {
3445 wxPyBLOCK_THREADS(PyErr_NoMemory());
3446 return;
3447 }
3448 memcpy(copy, data, DATASIZE);
3449 self->SetData(copy, false);
3450 // wxImage takes ownership of copy...
3451 }
3452 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3453 buffer data = self->GetData();
3454 int len = self->GetWidth() * self->GetHeight() * 3;
3455 PyObject* rv;
3456 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3457 return rv;
3458 }
3459 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3460 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3461 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3462 return;
3463 }
3464 self->SetData(data, true);
3465 }
3466 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3467 buffer data = self->GetAlpha();
3468 if (! data) {
3469 RETURN_NONE();
3470 } else {
3471 int len = self->GetWidth() * self->GetHeight();
3472 PyObject* rv;
3473 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3474 return rv;
3475 }
3476 }
3477 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3478 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3479 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3480 return;
3481 }
3482 buffer acopy = (buffer)malloc(ALPHASIZE);
3483 if (acopy == NULL) {
3484 wxPyBLOCK_THREADS(PyErr_NoMemory());
3485 return;
3486 }
3487 memcpy(acopy, alpha, ALPHASIZE);
3488 self->SetAlpha(acopy, false);
3489 // wxImage takes ownership of acopy...
3490 }
3491 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3492 buffer data = self->GetAlpha();
3493 int len = self->GetWidth() * self->GetHeight();
3494 PyObject* rv;
3495 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3496 return rv;
3497 }
3498 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3499 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3500 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3501 return;
3502 }
3503 self->SetAlpha(alpha, true);
3504 }
3505 SWIGINTERN PyObject *wxImage_GetHandlers(){
3506 wxList& list = wxImage::GetHandlers();
3507 return wxPy_ConvertList(&list);
3508 }
3509 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3510 wxBitmap bitmap(*self, depth);
3511 return bitmap;
3512 }
3513 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3514 wxImage mono = self->ConvertToMono( red, green, blue );
3515 wxBitmap bitmap( mono, 1 );
3516 return bitmap;
3517 }
3518 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3519 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3520 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3521 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3522 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3523 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3524 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3525 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3526 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3527 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3528 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3529 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3530 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3531 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3532 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3533
3534 #include <wx/quantize.h>
3535
3536 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3537 return wxQuantize::Quantize(src, dest,
3538 //NULL, // palette
3539 desiredNoColours,
3540 NULL, // eightBitData
3541 flags);
3542 }
3543 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3544 if (PyCallable_Check(func)) {
3545 self->Connect(id, lastId, eventType,
3546 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3547 new wxPyCallback(func));
3548 }
3549 else if (func == Py_None) {
3550 self->Disconnect(id, lastId, eventType,
3551 (wxObjectEventFunction)
3552 &wxPyCallback::EventThunker);
3553 }
3554 else {
3555 wxPyBLOCK_THREADS(
3556 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3557 }
3558 }
3559 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3560 return self->Disconnect(id, lastId, eventType,
3561 (wxObjectEventFunction)
3562 &wxPyCallback::EventThunker);
3563 }
3564 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3565 if (_self && _self != Py_None) {
3566 self->SetClientObject(new wxPyOORClientData(_self, incref));
3567 }
3568 else {
3569 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3570 if (data) {
3571 self->SetClientObject(NULL); // This will delete it too
3572 }
3573 }
3574 }
3575
3576 #if ! wxUSE_HOTKEY
3577 #define wxEVT_HOTKEY -9999
3578 #endif
3579
3580 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3581 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3582 if (data) {
3583 Py_INCREF(data->m_obj);
3584 return data->m_obj;
3585 } else {
3586 Py_INCREF(Py_None);
3587 return Py_None;
3588 }
3589 }
3590 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3591 wxPyClientData* data = new wxPyClientData(clientData);
3592 self->SetClientObject(data);
3593 }
3594 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3595 #if wxUSE_UNICODE
3596 return self->GetUnicodeKey();
3597 #else
3598 return 0;
3599 #endif
3600 }
3601
3602 SWIGINTERNINLINE PyObject *
3603 SWIG_From_unsigned_SS_int (unsigned int value)
3604 {
3605 return SWIG_From_unsigned_SS_long (value);
3606 }
3607
3608
3609 SWIGINTERN int
3610 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3611 {
3612 unsigned long v;
3613 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3614 if (SWIG_IsOK(res)) {
3615 if ((v > UINT_MAX)) {
3616 return SWIG_OverflowError;
3617 } else {
3618 if (val) *val = static_cast< unsigned int >(v);
3619 }
3620 }
3621 return res;
3622 }
3623
3624 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3625 self->m_size = size;
3626 }
3627 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3628 int count = self->GetNumberOfFiles();
3629 wxString* files = self->GetFiles();
3630 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3631 PyObject* list = PyList_New(count);
3632
3633 if (!list) {
3634 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3635 wxPyEndBlockThreads(blocked);
3636 return NULL;
3637 }
3638
3639 for (int i=0; i<count; i++) {
3640 PyList_SetItem(list, i, wx2PyString(files[i]));
3641 }
3642 wxPyEndBlockThreads(blocked);
3643 return list;
3644 }
3645
3646
3647 SWIGINTERN wxPyApp *new_wxPyApp(){
3648 wxPythonApp = new wxPyApp();
3649 return wxPythonApp;
3650 }
3651
3652 void wxApp_CleanUp() {
3653 __wxPyCleanup();
3654 }
3655
3656
3657 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3658
3659
3660
3661
3662
3663 SWIGINTERNINLINE PyObject *
3664 SWIG_FromCharPtr(const char *cptr)
3665 {
3666 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3667 }
3668
3669
3670 #if 0 // #ifdef __WXMAC__
3671
3672 // A dummy class that raises an exception if used...
3673 class wxEventLoop
3674 {
3675 public:
3676 wxEventLoop() { wxPyRaiseNotImplemented(); }
3677 int Run() { return 0; }
3678 void Exit(int rc = 0) {}
3679 bool Pending() const { return false; }
3680 bool Dispatch() { return false; }
3681 bool IsRunning() const { return false; }
3682 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3683 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3684 };
3685
3686 #else
3687
3688 #include <wx/evtloop.h>
3689
3690 #endif
3691
3692
3693
3694 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3695 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3696 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3697 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3698 wxWindowList& list = self->GetChildren();
3699 return wxPy_ConvertList(&list);
3700 }
3701 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3702 #if wxUSE_HOTKEY
3703 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3704 #else
3705 return false;
3706 #endif
3707 }
3708 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3709
3710
3711
3712 return false;
3713
3714 }
3715 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3716 return wxPyGetWinHandle(self);
3717 }
3718 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3719 self->AssociateHandle((WXWidget)handle);
3720 }
3721
3722 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3723 return wxWindow::FindWindowById(id, parent);
3724 }
3725
3726 wxWindow* wxFindWindowByName( const wxString& name,
3727 const wxWindow *parent = NULL ) {
3728 return wxWindow::FindWindowByName(name, parent);
3729 }
3730
3731 wxWindow* wxFindWindowByLabel( const wxString& label,
3732 const wxWindow *parent = NULL ) {
3733 return wxWindow::FindWindowByLabel(label, parent);
3734 }
3735
3736
3737 #ifdef __WXMSW__
3738 #include <wx/msw/private.h> // to get wxGetWindowId
3739 #endif
3740
3741
3742 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3743 #ifdef __WXMSW__
3744 WXHWND hWnd = (WXHWND)_hWnd;
3745 long id = wxGetWindowId(hWnd);
3746 wxWindow* win = new wxWindow;
3747 if (parent)
3748 parent->AddChild(win);
3749 win->SetEventHandler(win);
3750 win->SetHWND(hWnd);
3751 win->SetId(id);
3752 win->SubclassWin(hWnd);
3753 win->AdoptAttributesFromHWND();
3754 win->SetupColours();
3755 return win;
3756 #else
3757 wxPyRaiseNotImplemented();
3758 return NULL;
3759 #endif
3760 }
3761
3762
3763 PyObject* GetTopLevelWindows() {
3764 return wxPy_ConvertList(&wxTopLevelWindows);
3765 }
3766
3767
3768 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3769 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3770 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3771
3772 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3773
3774
3775 SWIGINTERNINLINE int
3776 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3777 {
3778 unsigned long v;
3779 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3780 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3781 return res;
3782 }
3783
3784 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3785 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3786 wxMenuItemList& list = self->GetMenuItems();
3787 return wxPy_ConvertList(&list);
3788 }
3789 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3790 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3791 static const wxString wxPyControlNameStr(wxControlNameStr);
3792 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3793 if (clientData) {
3794 wxPyClientData* data = new wxPyClientData(clientData);
3795 return self->Append(item, data);
3796 } else
3797 return self->Append(item);
3798 }
3799 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
3800 if (clientData) {
3801 wxPyClientData* data = new wxPyClientData(clientData);
3802 return self->Insert(item, pos, data);
3803 } else
3804 return self->Insert(item, pos);
3805 }
3806 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
3807 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3808 if (data) {
3809 Py_INCREF(data->m_obj);
3810 return data->m_obj;
3811 } else {
3812 Py_INCREF(Py_None);
3813 return Py_None;
3814 }
3815 }
3816 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
3817 wxPyClientData* data = new wxPyClientData(clientData);
3818 self->SetClientObject(n, data);
3819 }
3820
3821
3822 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3823 wxPyUserData* data = NULL;
3824 if ( userData ) {
3825 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3826 data = new wxPyUserData(userData);
3827 wxPyEndBlockThreads(blocked);
3828 }
3829 return new wxSizerItem(window, proportion, flag, border, data);
3830 }
3831 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3832 wxPyUserData* data = NULL;
3833 if ( userData ) {
3834 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3835 data = new wxPyUserData(userData);
3836 wxPyEndBlockThreads(blocked);
3837 }
3838 return new wxSizerItem(width, height, proportion, flag, border, data);
3839 }
3840 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3841 wxPyUserData* data = NULL;
3842 if ( userData ) {
3843 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3844 data = new wxPyUserData(userData);
3845 wxPyEndBlockThreads(blocked);
3846 }
3847 return new wxSizerItem(sizer, proportion, flag, border, data);
3848 }
3849
3850 #include <float.h>
3851
3852
3853 SWIGINTERN int
3854 SWIG_AsVal_float (PyObject * obj, float *val)
3855 {
3856 double v;
3857 int res = SWIG_AsVal_double (obj, &v);
3858 if (SWIG_IsOK(res)) {
3859 if ((v < -FLT_MAX || v > FLT_MAX)) {
3860 return SWIG_OverflowError;
3861 } else {
3862 if (val) *val = static_cast< float >(v);
3863 }
3864 }
3865 return res;
3866 }
3867
3868
3869 SWIGINTERNINLINE PyObject *
3870 SWIG_From_float (float value)
3871 {
3872 return SWIG_From_double (value);
3873 }
3874
3875 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3876 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3877 if (data) {
3878 Py_INCREF(data->m_obj);
3879 return data->m_obj;
3880 } else {
3881 Py_INCREF(Py_None);
3882 return Py_None;
3883 }
3884 }
3885 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3886 wxPyUserData* data = NULL;
3887 if ( userData ) {
3888 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3889 data = new wxPyUserData(userData);
3890 wxPyEndBlockThreads(blocked);
3891 }
3892 self->SetUserData(data);
3893 }
3894
3895 // Figure out the type of the sizer item
3896
3897 struct wxPySizerItemInfo {
3898 wxPySizerItemInfo()
3899 : window(NULL), sizer(NULL), gotSize(false),
3900 size(wxDefaultSize), gotPos(false), pos(-1)
3901 {}
3902
3903 wxWindow* window;
3904 wxSizer* sizer;
3905 bool gotSize;
3906 wxSize size;
3907 bool gotPos;
3908 int pos;
3909 };
3910
3911 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3912
3913 wxPySizerItemInfo info;
3914 wxSize size;
3915 wxSize* sizePtr = &size;
3916
3917 // Find out what the type of the item is
3918 // try wxWindow
3919 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3920 PyErr_Clear();
3921 info.window = NULL;
3922
3923 // try wxSizer
3924 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3925 PyErr_Clear();
3926 info.sizer = NULL;
3927
3928 // try wxSize or (w,h)
3929 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3930 info.size = *sizePtr;
3931 info.gotSize = true;
3932 }
3933
3934 // or a single int
3935 if (checkIdx && PyInt_Check(item)) {
3936 info.pos = PyInt_AsLong(item);
3937 info.gotPos = true;
3938 }
3939 }
3940 }
3941
3942 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3943 // no expected type, figure out what kind of error message to generate
3944 if ( !checkSize && !checkIdx )
3945 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3946 else if ( checkSize && !checkIdx )
3947 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3948 else if ( !checkSize && checkIdx)
3949 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3950 else
3951 // can this one happen?
3952 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3953 }
3954
3955 return info;
3956 }
3957
3958 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3959 if (!self->GetClientObject())
3960 self->SetClientObject(new wxPyOORClientData(_self));
3961 }
3962 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3963
3964 wxPyUserData* data = NULL;
3965 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3966 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3967 if ( userData && (info.window || info.sizer || info.gotSize) )
3968 data = new wxPyUserData(userData);
3969 if ( info.sizer )
3970 PyObject_SetAttrString(item,"thisown",Py_False);
3971 wxPyEndBlockThreads(blocked);
3972
3973 // Now call the real Add method if a valid item type was found
3974 if ( info.window )
3975 return self->Add(info.window, proportion, flag, border, data);
3976 else if ( info.sizer )
3977 return self->Add(info.sizer, proportion, flag, border, data);
3978 else if (info.gotSize)
3979 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3980 proportion, flag, border, data);
3981 else
3982 return NULL;
3983 }
3984 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3985
3986 wxPyUserData* data = NULL;
3987 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3988 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3989 if ( userData && (info.window || info.sizer || info.gotSize) )
3990 data = new wxPyUserData(userData);
3991 if ( info.sizer )
3992 PyObject_SetAttrString(item,"thisown",Py_False);
3993 wxPyEndBlockThreads(blocked);
3994
3995 // Now call the real Insert method if a valid item type was found
3996 if ( info.window )
3997 return self->Insert(before, info.window, proportion, flag, border, data);
3998 else if ( info.sizer )
3999 return self->Insert(before, info.sizer, proportion, flag, border, data);
4000 else if (info.gotSize)
4001 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4002 proportion, flag, border, data);
4003 else
4004 return NULL;
4005 }
4006 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4007
4008 wxPyUserData* data = NULL;
4009 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4010 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4011 if ( userData && (info.window || info.sizer || info.gotSize) )
4012 data = new wxPyUserData(userData);
4013 if ( info.sizer )
4014 PyObject_SetAttrString(item,"thisown",Py_False);
4015 wxPyEndBlockThreads(blocked);
4016
4017 // Now call the real Prepend method if a valid item type was found
4018 if ( info.window )
4019 return self->Prepend(info.window, proportion, flag, border, data);
4020 else if ( info.sizer )
4021 return self->Prepend(info.sizer, proportion, flag, border, data);
4022 else if (info.gotSize)
4023 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4024 proportion, flag, border, data);
4025 else
4026 return NULL;
4027 }
4028 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4030 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4031 wxPyEndBlockThreads(blocked);
4032 if ( info.window )
4033 return self->Remove(info.window);
4034 else if ( info.sizer )
4035 return self->Remove(info.sizer);
4036 else if ( info.gotPos )
4037 return self->Remove(info.pos);
4038 else
4039 return false;
4040 }
4041 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4042 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4043 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4044 wxPyEndBlockThreads(blocked);
4045 if ( info.window )
4046 return self->Detach(info.window);
4047 else if ( info.sizer )
4048 return self->Detach(info.sizer);
4049 else if ( info.gotPos )
4050 return self->Detach(info.pos);
4051 else
4052 return false;
4053 }
4054 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4055 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4056 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4057 wxPyEndBlockThreads(blocked);
4058 if ( info.window )
4059 return self->GetItem(info.window);
4060 else if ( info.sizer )
4061 return self->GetItem(info.sizer);
4062 else if ( info.gotPos )
4063 return self->GetItem(info.pos);
4064 else
4065 return NULL;
4066 }
4067 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4068 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4069 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4070 wxPyEndBlockThreads(blocked);
4071 if ( info.window )
4072 self->SetItemMinSize(info.window, size);
4073 else if ( info.sizer )
4074 self->SetItemMinSize(info.sizer, size);
4075 else if ( info.gotPos )
4076 self->SetItemMinSize(info.pos, size);
4077 }
4078 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4079 wxSizerItemList& list = self->GetChildren();
4080 return wxPy_ConvertList(&list);
4081 }
4082 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4084 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4085 wxPyEndBlockThreads(blocked);
4086 if ( info.window )
4087 return self->Show(info.window, show, recursive);
4088 else if ( info.sizer )
4089 return self->Show(info.sizer, show, recursive);
4090 else if ( info.gotPos )
4091 return self->Show(info.pos, show);
4092 else
4093 return false;
4094 }
4095 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4096 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4097 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4098 wxPyEndBlockThreads(blocked);
4099 if ( info.window )
4100 return self->IsShown(info.window);
4101 else if ( info.sizer )
4102 return self->IsShown(info.sizer);
4103 else if ( info.gotPos )
4104 return self->IsShown(info.pos);
4105 else
4106 return false;
4107 }
4108
4109 // See pyclasses.h
4110 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4111 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4112 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4113
4114
4115
4116
4117 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4118 {
4119 if (source == Py_None) {
4120 **obj = wxGBPosition(-1,-1);
4121 return true;
4122 }
4123 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4124 }
4125
4126 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4127 {
4128 if (source == Py_None) {
4129 **obj = wxGBSpan(-1,-1);
4130 return true;
4131 }
4132 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4133 }
4134
4135
4136 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4137 self->SetRow(row);
4138 self->SetCol(col);
4139 }
4140 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4141 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4142 PyObject* tup = PyTuple_New(2);
4143 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4144 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4145 wxPyEndBlockThreads(blocked);
4146 return tup;
4147 }
4148 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4149 self->SetRowspan(rowspan);
4150 self->SetColspan(colspan);
4151 }
4152 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4153 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4154 PyObject* tup = PyTuple_New(2);
4155 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4156 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4157 wxPyEndBlockThreads(blocked);
4158 return tup;
4159 }
4160 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4161 wxPyUserData* data = NULL;
4162 if ( userData ) {
4163 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4164 data = new wxPyUserData(userData);
4165 wxPyEndBlockThreads(blocked);
4166 }
4167 return new wxGBSizerItem(window, pos, span, flag, border, data);
4168 }
4169 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4170 wxPyUserData* data = NULL;
4171 if ( userData ) {
4172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4173 data = new wxPyUserData(userData);
4174 wxPyEndBlockThreads(blocked);
4175 }
4176 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4177 }
4178 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4179 wxPyUserData* data = NULL;
4180 if ( userData ) {
4181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4182 data = new wxPyUserData(userData);
4183 wxPyEndBlockThreads(blocked);
4184 }
4185 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4186 }
4187 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4188 int row, col;
4189 self->GetEndPos(row, col);
4190 return wxGBPosition(row, col);
4191 }
4192 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4193
4194 wxPyUserData* data = NULL;
4195 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4196 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4197 if ( userData && (info.window || info.sizer || info.gotSize) )
4198 data = new wxPyUserData(userData);
4199 if ( info.sizer )
4200 PyObject_SetAttrString(item,"thisown",Py_False);
4201 wxPyEndBlockThreads(blocked);
4202
4203 // Now call the real Add method if a valid item type was found
4204 if ( info.window )
4205 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4206 else if ( info.sizer )
4207 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4208 else if (info.gotSize)
4209 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4210 pos, span, flag, border, data);
4211 return NULL;
4212 }
4213
4214
4215 #ifdef __cplusplus
4216 extern "C" {
4217 #endif
4218 SWIGINTERN int EmptyString_set(PyObject *) {
4219 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4220 return 1;
4221 }
4222
4223
4224 SWIGINTERN PyObject *EmptyString_get(void) {
4225 PyObject *pyobj = 0;
4226
4227 {
4228 #if wxUSE_UNICODE
4229 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4230 #else
4231 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4232 #endif
4233 }
4234 return pyobj;
4235 }
4236
4237
4238 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4239 PyObject *resultobj = 0;
4240 wxObject *arg1 = (wxObject *) 0 ;
4241 wxString result;
4242 void *argp1 = 0 ;
4243 int res1 = 0 ;
4244 PyObject *swig_obj[1] ;
4245
4246 if (!args) SWIG_fail;
4247 swig_obj[0] = args;
4248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4249 if (!SWIG_IsOK(res1)) {
4250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4251 }
4252 arg1 = reinterpret_cast< wxObject * >(argp1);
4253 {
4254 PyThreadState* __tstate = wxPyBeginAllowThreads();
4255 result = wxObject_GetClassName(arg1);
4256 wxPyEndAllowThreads(__tstate);
4257 if (PyErr_Occurred()) SWIG_fail;
4258 }
4259 {
4260 #if wxUSE_UNICODE
4261 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4262 #else
4263 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4264 #endif
4265 }
4266 return resultobj;
4267 fail:
4268 return NULL;
4269 }
4270
4271
4272 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4273 PyObject *resultobj = 0;
4274 wxObject *arg1 = (wxObject *) 0 ;
4275 void *argp1 = 0 ;
4276 int res1 = 0 ;
4277 PyObject *swig_obj[1] ;
4278
4279 if (!args) SWIG_fail;
4280 swig_obj[0] = args;
4281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4282 if (!SWIG_IsOK(res1)) {
4283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4284 }
4285 arg1 = reinterpret_cast< wxObject * >(argp1);
4286 {
4287 PyThreadState* __tstate = wxPyBeginAllowThreads();
4288 wxObject_Destroy(arg1);
4289 wxPyEndAllowThreads(__tstate);
4290 if (PyErr_Occurred()) SWIG_fail;
4291 }
4292 resultobj = SWIG_Py_Void();
4293 return resultobj;
4294 fail:
4295 return NULL;
4296 }
4297
4298
4299 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4300 PyObject *obj;
4301 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4302 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4303 return SWIG_Py_Void();
4304 }
4305
4306 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4307 PyObject *resultobj = 0;
4308 wxSize *arg1 = (wxSize *) 0 ;
4309 int arg2 ;
4310 void *argp1 = 0 ;
4311 int res1 = 0 ;
4312 int val2 ;
4313 int ecode2 = 0 ;
4314 PyObject *swig_obj[2] ;
4315
4316 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4318 if (!SWIG_IsOK(res1)) {
4319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4320 }
4321 arg1 = reinterpret_cast< wxSize * >(argp1);
4322 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4323 if (!SWIG_IsOK(ecode2)) {
4324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4325 }
4326 arg2 = static_cast< int >(val2);
4327 if (arg1) (arg1)->x = arg2;
4328
4329 resultobj = SWIG_Py_Void();
4330 return resultobj;
4331 fail:
4332 return NULL;
4333 }
4334
4335
4336 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4337 PyObject *resultobj = 0;
4338 wxSize *arg1 = (wxSize *) 0 ;
4339 int result;
4340 void *argp1 = 0 ;
4341 int res1 = 0 ;
4342 PyObject *swig_obj[1] ;
4343
4344 if (!args) SWIG_fail;
4345 swig_obj[0] = args;
4346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4347 if (!SWIG_IsOK(res1)) {
4348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4349 }
4350 arg1 = reinterpret_cast< wxSize * >(argp1);
4351 result = (int) ((arg1)->x);
4352 resultobj = SWIG_From_int(static_cast< int >(result));
4353 return resultobj;
4354 fail:
4355 return NULL;
4356 }
4357
4358
4359 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4360 PyObject *resultobj = 0;
4361 wxSize *arg1 = (wxSize *) 0 ;
4362 int arg2 ;
4363 void *argp1 = 0 ;
4364 int res1 = 0 ;
4365 int val2 ;
4366 int ecode2 = 0 ;
4367 PyObject *swig_obj[2] ;
4368
4369 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4371 if (!SWIG_IsOK(res1)) {
4372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4373 }
4374 arg1 = reinterpret_cast< wxSize * >(argp1);
4375 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4376 if (!SWIG_IsOK(ecode2)) {
4377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4378 }
4379 arg2 = static_cast< int >(val2);
4380 if (arg1) (arg1)->y = arg2;
4381
4382 resultobj = SWIG_Py_Void();
4383 return resultobj;
4384 fail:
4385 return NULL;
4386 }
4387
4388
4389 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4390 PyObject *resultobj = 0;
4391 wxSize *arg1 = (wxSize *) 0 ;
4392 int result;
4393 void *argp1 = 0 ;
4394 int res1 = 0 ;
4395 PyObject *swig_obj[1] ;
4396
4397 if (!args) SWIG_fail;
4398 swig_obj[0] = args;
4399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4400 if (!SWIG_IsOK(res1)) {
4401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4402 }
4403 arg1 = reinterpret_cast< wxSize * >(argp1);
4404 result = (int) ((arg1)->y);
4405 resultobj = SWIG_From_int(static_cast< int >(result));
4406 return resultobj;
4407 fail:
4408 return NULL;
4409 }
4410
4411
4412 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4413 PyObject *resultobj = 0;
4414 int arg1 = (int) 0 ;
4415 int arg2 = (int) 0 ;
4416 wxSize *result = 0 ;
4417 int val1 ;
4418 int ecode1 = 0 ;
4419 int val2 ;
4420 int ecode2 = 0 ;
4421 PyObject * obj0 = 0 ;
4422 PyObject * obj1 = 0 ;
4423 char * kwnames[] = {
4424 (char *) "w",(char *) "h", NULL
4425 };
4426
4427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4428 if (obj0) {
4429 ecode1 = SWIG_AsVal_int(obj0, &val1);
4430 if (!SWIG_IsOK(ecode1)) {
4431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4432 }
4433 arg1 = static_cast< int >(val1);
4434 }
4435 if (obj1) {
4436 ecode2 = SWIG_AsVal_int(obj1, &val2);
4437 if (!SWIG_IsOK(ecode2)) {
4438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4439 }
4440 arg2 = static_cast< int >(val2);
4441 }
4442 {
4443 PyThreadState* __tstate = wxPyBeginAllowThreads();
4444 result = (wxSize *)new wxSize(arg1,arg2);
4445 wxPyEndAllowThreads(__tstate);
4446 if (PyErr_Occurred()) SWIG_fail;
4447 }
4448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4449 return resultobj;
4450 fail:
4451 return NULL;
4452 }
4453
4454
4455 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4456 PyObject *resultobj = 0;
4457 wxSize *arg1 = (wxSize *) 0 ;
4458 void *argp1 = 0 ;
4459 int res1 = 0 ;
4460 PyObject *swig_obj[1] ;
4461
4462 if (!args) SWIG_fail;
4463 swig_obj[0] = args;
4464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4465 if (!SWIG_IsOK(res1)) {
4466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4467 }
4468 arg1 = reinterpret_cast< wxSize * >(argp1);
4469 {
4470 PyThreadState* __tstate = wxPyBeginAllowThreads();
4471 delete arg1;
4472
4473 wxPyEndAllowThreads(__tstate);
4474 if (PyErr_Occurred()) SWIG_fail;
4475 }
4476 resultobj = SWIG_Py_Void();
4477 return resultobj;
4478 fail:
4479 return NULL;
4480 }
4481
4482
4483 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4484 PyObject *resultobj = 0;
4485 wxSize *arg1 = (wxSize *) 0 ;
4486 wxSize *arg2 = 0 ;
4487 bool result;
4488 void *argp1 = 0 ;
4489 int res1 = 0 ;
4490 wxSize temp2 ;
4491 PyObject * obj0 = 0 ;
4492 PyObject * obj1 = 0 ;
4493 char * kwnames[] = {
4494 (char *) "self",(char *) "sz", NULL
4495 };
4496
4497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4499 if (!SWIG_IsOK(res1)) {
4500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4501 }
4502 arg1 = reinterpret_cast< wxSize * >(argp1);
4503 {
4504 arg2 = &temp2;
4505 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4506 }
4507 {
4508 PyThreadState* __tstate = wxPyBeginAllowThreads();
4509 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
4510 wxPyEndAllowThreads(__tstate);
4511 if (PyErr_Occurred()) SWIG_fail;
4512 }
4513 {
4514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4515 }
4516 return resultobj;
4517 fail:
4518 return NULL;
4519 }
4520
4521
4522 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4523 PyObject *resultobj = 0;
4524 wxSize *arg1 = (wxSize *) 0 ;
4525 wxSize *arg2 = 0 ;
4526 bool result;
4527 void *argp1 = 0 ;
4528 int res1 = 0 ;
4529 wxSize temp2 ;
4530 PyObject * obj0 = 0 ;
4531 PyObject * obj1 = 0 ;
4532 char * kwnames[] = {
4533 (char *) "self",(char *) "sz", NULL
4534 };
4535
4536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4538 if (!SWIG_IsOK(res1)) {
4539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4540 }
4541 arg1 = reinterpret_cast< wxSize * >(argp1);
4542 {
4543 arg2 = &temp2;
4544 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4545 }
4546 {
4547 PyThreadState* __tstate = wxPyBeginAllowThreads();
4548 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
4549 wxPyEndAllowThreads(__tstate);
4550 if (PyErr_Occurred()) SWIG_fail;
4551 }
4552 {
4553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4554 }
4555 return resultobj;
4556 fail:
4557 return NULL;
4558 }
4559
4560
4561 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4562 PyObject *resultobj = 0;
4563 wxSize *arg1 = (wxSize *) 0 ;
4564 wxSize *arg2 = 0 ;
4565 wxSize result;
4566 void *argp1 = 0 ;
4567 int res1 = 0 ;
4568 wxSize temp2 ;
4569 PyObject * obj0 = 0 ;
4570 PyObject * obj1 = 0 ;
4571 char * kwnames[] = {
4572 (char *) "self",(char *) "sz", NULL
4573 };
4574
4575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4577 if (!SWIG_IsOK(res1)) {
4578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4579 }
4580 arg1 = reinterpret_cast< wxSize * >(argp1);
4581 {
4582 arg2 = &temp2;
4583 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4584 }
4585 {
4586 PyThreadState* __tstate = wxPyBeginAllowThreads();
4587 result = (arg1)->operator +((wxSize const &)*arg2);
4588 wxPyEndAllowThreads(__tstate);
4589 if (PyErr_Occurred()) SWIG_fail;
4590 }
4591 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4592 return resultobj;
4593 fail:
4594 return NULL;
4595 }
4596
4597
4598 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4599 PyObject *resultobj = 0;
4600 wxSize *arg1 = (wxSize *) 0 ;
4601 wxSize *arg2 = 0 ;
4602 wxSize result;
4603 void *argp1 = 0 ;
4604 int res1 = 0 ;
4605 wxSize temp2 ;
4606 PyObject * obj0 = 0 ;
4607 PyObject * obj1 = 0 ;
4608 char * kwnames[] = {
4609 (char *) "self",(char *) "sz", NULL
4610 };
4611
4612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4614 if (!SWIG_IsOK(res1)) {
4615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4616 }
4617 arg1 = reinterpret_cast< wxSize * >(argp1);
4618 {
4619 arg2 = &temp2;
4620 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4621 }
4622 {
4623 PyThreadState* __tstate = wxPyBeginAllowThreads();
4624 result = (arg1)->operator -((wxSize const &)*arg2);
4625 wxPyEndAllowThreads(__tstate);
4626 if (PyErr_Occurred()) SWIG_fail;
4627 }
4628 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4629 return resultobj;
4630 fail:
4631 return NULL;
4632 }
4633
4634
4635 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4636 PyObject *resultobj = 0;
4637 wxSize *arg1 = (wxSize *) 0 ;
4638 wxSize *arg2 = 0 ;
4639 void *argp1 = 0 ;
4640 int res1 = 0 ;
4641 wxSize temp2 ;
4642 PyObject * obj0 = 0 ;
4643 PyObject * obj1 = 0 ;
4644 char * kwnames[] = {
4645 (char *) "self",(char *) "sz", NULL
4646 };
4647
4648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4650 if (!SWIG_IsOK(res1)) {
4651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4652 }
4653 arg1 = reinterpret_cast< wxSize * >(argp1);
4654 {
4655 arg2 = &temp2;
4656 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4657 }
4658 {
4659 PyThreadState* __tstate = wxPyBeginAllowThreads();
4660 (arg1)->IncTo((wxSize const &)*arg2);
4661 wxPyEndAllowThreads(__tstate);
4662 if (PyErr_Occurred()) SWIG_fail;
4663 }
4664 resultobj = SWIG_Py_Void();
4665 return resultobj;
4666 fail:
4667 return NULL;
4668 }
4669
4670
4671 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4672 PyObject *resultobj = 0;
4673 wxSize *arg1 = (wxSize *) 0 ;
4674 wxSize *arg2 = 0 ;
4675 void *argp1 = 0 ;
4676 int res1 = 0 ;
4677 wxSize temp2 ;
4678 PyObject * obj0 = 0 ;
4679 PyObject * obj1 = 0 ;
4680 char * kwnames[] = {
4681 (char *) "self",(char *) "sz", NULL
4682 };
4683
4684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4686 if (!SWIG_IsOK(res1)) {
4687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4688 }
4689 arg1 = reinterpret_cast< wxSize * >(argp1);
4690 {
4691 arg2 = &temp2;
4692 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4693 }
4694 {
4695 PyThreadState* __tstate = wxPyBeginAllowThreads();
4696 (arg1)->DecTo((wxSize const &)*arg2);
4697 wxPyEndAllowThreads(__tstate);
4698 if (PyErr_Occurred()) SWIG_fail;
4699 }
4700 resultobj = SWIG_Py_Void();
4701 return resultobj;
4702 fail:
4703 return NULL;
4704 }
4705
4706
4707 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4708 PyObject *resultobj = 0;
4709 wxSize *arg1 = (wxSize *) 0 ;
4710 int arg2 ;
4711 int arg3 ;
4712 void *argp1 = 0 ;
4713 int res1 = 0 ;
4714 int val2 ;
4715 int ecode2 = 0 ;
4716 int val3 ;
4717 int ecode3 = 0 ;
4718 PyObject * obj0 = 0 ;
4719 PyObject * obj1 = 0 ;
4720 PyObject * obj2 = 0 ;
4721 char * kwnames[] = {
4722 (char *) "self",(char *) "w",(char *) "h", NULL
4723 };
4724
4725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4727 if (!SWIG_IsOK(res1)) {
4728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4729 }
4730 arg1 = reinterpret_cast< wxSize * >(argp1);
4731 ecode2 = SWIG_AsVal_int(obj1, &val2);
4732 if (!SWIG_IsOK(ecode2)) {
4733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4734 }
4735 arg2 = static_cast< int >(val2);
4736 ecode3 = SWIG_AsVal_int(obj2, &val3);
4737 if (!SWIG_IsOK(ecode3)) {
4738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4739 }
4740 arg3 = static_cast< int >(val3);
4741 {
4742 PyThreadState* __tstate = wxPyBeginAllowThreads();
4743 (arg1)->Set(arg2,arg3);
4744 wxPyEndAllowThreads(__tstate);
4745 if (PyErr_Occurred()) SWIG_fail;
4746 }
4747 resultobj = SWIG_Py_Void();
4748 return resultobj;
4749 fail:
4750 return NULL;
4751 }
4752
4753
4754 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4755 PyObject *resultobj = 0;
4756 wxSize *arg1 = (wxSize *) 0 ;
4757 int arg2 ;
4758 void *argp1 = 0 ;
4759 int res1 = 0 ;
4760 int val2 ;
4761 int ecode2 = 0 ;
4762 PyObject * obj0 = 0 ;
4763 PyObject * obj1 = 0 ;
4764 char * kwnames[] = {
4765 (char *) "self",(char *) "w", NULL
4766 };
4767
4768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4770 if (!SWIG_IsOK(res1)) {
4771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4772 }
4773 arg1 = reinterpret_cast< wxSize * >(argp1);
4774 ecode2 = SWIG_AsVal_int(obj1, &val2);
4775 if (!SWIG_IsOK(ecode2)) {
4776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4777 }
4778 arg2 = static_cast< int >(val2);
4779 {
4780 PyThreadState* __tstate = wxPyBeginAllowThreads();
4781 (arg1)->SetWidth(arg2);
4782 wxPyEndAllowThreads(__tstate);
4783 if (PyErr_Occurred()) SWIG_fail;
4784 }
4785 resultobj = SWIG_Py_Void();
4786 return resultobj;
4787 fail:
4788 return NULL;
4789 }
4790
4791
4792 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4793 PyObject *resultobj = 0;
4794 wxSize *arg1 = (wxSize *) 0 ;
4795 int arg2 ;
4796 void *argp1 = 0 ;
4797 int res1 = 0 ;
4798 int val2 ;
4799 int ecode2 = 0 ;
4800 PyObject * obj0 = 0 ;
4801 PyObject * obj1 = 0 ;
4802 char * kwnames[] = {
4803 (char *) "self",(char *) "h", NULL
4804 };
4805
4806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4808 if (!SWIG_IsOK(res1)) {
4809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4810 }
4811 arg1 = reinterpret_cast< wxSize * >(argp1);
4812 ecode2 = SWIG_AsVal_int(obj1, &val2);
4813 if (!SWIG_IsOK(ecode2)) {
4814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4815 }
4816 arg2 = static_cast< int >(val2);
4817 {
4818 PyThreadState* __tstate = wxPyBeginAllowThreads();
4819 (arg1)->SetHeight(arg2);
4820 wxPyEndAllowThreads(__tstate);
4821 if (PyErr_Occurred()) SWIG_fail;
4822 }
4823 resultobj = SWIG_Py_Void();
4824 return resultobj;
4825 fail:
4826 return NULL;
4827 }
4828
4829
4830 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4831 PyObject *resultobj = 0;
4832 wxSize *arg1 = (wxSize *) 0 ;
4833 int result;
4834 void *argp1 = 0 ;
4835 int res1 = 0 ;
4836 PyObject *swig_obj[1] ;
4837
4838 if (!args) SWIG_fail;
4839 swig_obj[0] = args;
4840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4841 if (!SWIG_IsOK(res1)) {
4842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4843 }
4844 arg1 = reinterpret_cast< wxSize * >(argp1);
4845 {
4846 PyThreadState* __tstate = wxPyBeginAllowThreads();
4847 result = (int)((wxSize const *)arg1)->GetWidth();
4848 wxPyEndAllowThreads(__tstate);
4849 if (PyErr_Occurred()) SWIG_fail;
4850 }
4851 resultobj = SWIG_From_int(static_cast< int >(result));
4852 return resultobj;
4853 fail:
4854 return NULL;
4855 }
4856
4857
4858 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4859 PyObject *resultobj = 0;
4860 wxSize *arg1 = (wxSize *) 0 ;
4861 int result;
4862 void *argp1 = 0 ;
4863 int res1 = 0 ;
4864 PyObject *swig_obj[1] ;
4865
4866 if (!args) SWIG_fail;
4867 swig_obj[0] = args;
4868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4869 if (!SWIG_IsOK(res1)) {
4870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4871 }
4872 arg1 = reinterpret_cast< wxSize * >(argp1);
4873 {
4874 PyThreadState* __tstate = wxPyBeginAllowThreads();
4875 result = (int)((wxSize const *)arg1)->GetHeight();
4876 wxPyEndAllowThreads(__tstate);
4877 if (PyErr_Occurred()) SWIG_fail;
4878 }
4879 resultobj = SWIG_From_int(static_cast< int >(result));
4880 return resultobj;
4881 fail:
4882 return NULL;
4883 }
4884
4885
4886 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4887 PyObject *resultobj = 0;
4888 wxSize *arg1 = (wxSize *) 0 ;
4889 bool result;
4890 void *argp1 = 0 ;
4891 int res1 = 0 ;
4892 PyObject *swig_obj[1] ;
4893
4894 if (!args) SWIG_fail;
4895 swig_obj[0] = args;
4896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4897 if (!SWIG_IsOK(res1)) {
4898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
4899 }
4900 arg1 = reinterpret_cast< wxSize * >(argp1);
4901 {
4902 PyThreadState* __tstate = wxPyBeginAllowThreads();
4903 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4904 wxPyEndAllowThreads(__tstate);
4905 if (PyErr_Occurred()) SWIG_fail;
4906 }
4907 {
4908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4909 }
4910 return resultobj;
4911 fail:
4912 return NULL;
4913 }
4914
4915
4916 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4917 PyObject *resultobj = 0;
4918 wxSize *arg1 = (wxSize *) 0 ;
4919 wxSize *arg2 = 0 ;
4920 void *argp1 = 0 ;
4921 int res1 = 0 ;
4922 wxSize temp2 ;
4923 PyObject * obj0 = 0 ;
4924 PyObject * obj1 = 0 ;
4925 char * kwnames[] = {
4926 (char *) "self",(char *) "size", NULL
4927 };
4928
4929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
4930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4931 if (!SWIG_IsOK(res1)) {
4932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
4933 }
4934 arg1 = reinterpret_cast< wxSize * >(argp1);
4935 {
4936 arg2 = &temp2;
4937 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4938 }
4939 {
4940 PyThreadState* __tstate = wxPyBeginAllowThreads();
4941 (arg1)->SetDefaults((wxSize const &)*arg2);
4942 wxPyEndAllowThreads(__tstate);
4943 if (PyErr_Occurred()) SWIG_fail;
4944 }
4945 resultobj = SWIG_Py_Void();
4946 return resultobj;
4947 fail:
4948 return NULL;
4949 }
4950
4951
4952 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4953 PyObject *resultobj = 0;
4954 wxSize *arg1 = (wxSize *) 0 ;
4955 PyObject *result = 0 ;
4956 void *argp1 = 0 ;
4957 int res1 = 0 ;
4958 PyObject *swig_obj[1] ;
4959
4960 if (!args) SWIG_fail;
4961 swig_obj[0] = args;
4962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4963 if (!SWIG_IsOK(res1)) {
4964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
4965 }
4966 arg1 = reinterpret_cast< wxSize * >(argp1);
4967 {
4968 PyThreadState* __tstate = wxPyBeginAllowThreads();
4969 result = (PyObject *)wxSize_Get(arg1);
4970 wxPyEndAllowThreads(__tstate);
4971 if (PyErr_Occurred()) SWIG_fail;
4972 }
4973 resultobj = result;
4974 return resultobj;
4975 fail:
4976 return NULL;
4977 }
4978
4979
4980 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4981 PyObject *obj;
4982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4983 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
4984 return SWIG_Py_Void();
4985 }
4986
4987 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4988 return SWIG_Python_InitShadowInstance(args);
4989 }
4990
4991 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4992 PyObject *resultobj = 0;
4993 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4994 double arg2 ;
4995 void *argp1 = 0 ;
4996 int res1 = 0 ;
4997 double val2 ;
4998 int ecode2 = 0 ;
4999 PyObject *swig_obj[2] ;
5000
5001 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5003 if (!SWIG_IsOK(res1)) {
5004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5005 }
5006 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5007 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5008 if (!SWIG_IsOK(ecode2)) {
5009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5010 }
5011 arg2 = static_cast< double >(val2);
5012 if (arg1) (arg1)->x = arg2;
5013
5014 resultobj = SWIG_Py_Void();
5015 return resultobj;
5016 fail:
5017 return NULL;
5018 }
5019
5020
5021 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5022 PyObject *resultobj = 0;
5023 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5024 double result;
5025 void *argp1 = 0 ;
5026 int res1 = 0 ;
5027 PyObject *swig_obj[1] ;
5028
5029 if (!args) SWIG_fail;
5030 swig_obj[0] = args;
5031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5032 if (!SWIG_IsOK(res1)) {
5033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5034 }
5035 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5036 result = (double) ((arg1)->x);
5037 resultobj = SWIG_From_double(static_cast< double >(result));
5038 return resultobj;
5039 fail:
5040 return NULL;
5041 }
5042
5043
5044 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5045 PyObject *resultobj = 0;
5046 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5047 double arg2 ;
5048 void *argp1 = 0 ;
5049 int res1 = 0 ;
5050 double val2 ;
5051 int ecode2 = 0 ;
5052 PyObject *swig_obj[2] ;
5053
5054 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5056 if (!SWIG_IsOK(res1)) {
5057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5058 }
5059 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5060 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5061 if (!SWIG_IsOK(ecode2)) {
5062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5063 }
5064 arg2 = static_cast< double >(val2);
5065 if (arg1) (arg1)->y = arg2;
5066
5067 resultobj = SWIG_Py_Void();
5068 return resultobj;
5069 fail:
5070 return NULL;
5071 }
5072
5073
5074 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5075 PyObject *resultobj = 0;
5076 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5077 double result;
5078 void *argp1 = 0 ;
5079 int res1 = 0 ;
5080 PyObject *swig_obj[1] ;
5081
5082 if (!args) SWIG_fail;
5083 swig_obj[0] = args;
5084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5085 if (!SWIG_IsOK(res1)) {
5086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5087 }
5088 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5089 result = (double) ((arg1)->y);
5090 resultobj = SWIG_From_double(static_cast< double >(result));
5091 return resultobj;
5092 fail:
5093 return NULL;
5094 }
5095
5096
5097 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5098 PyObject *resultobj = 0;
5099 double arg1 = (double) 0.0 ;
5100 double arg2 = (double) 0.0 ;
5101 wxRealPoint *result = 0 ;
5102 double val1 ;
5103 int ecode1 = 0 ;
5104 double val2 ;
5105 int ecode2 = 0 ;
5106 PyObject * obj0 = 0 ;
5107 PyObject * obj1 = 0 ;
5108 char * kwnames[] = {
5109 (char *) "x",(char *) "y", NULL
5110 };
5111
5112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5113 if (obj0) {
5114 ecode1 = SWIG_AsVal_double(obj0, &val1);
5115 if (!SWIG_IsOK(ecode1)) {
5116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5117 }
5118 arg1 = static_cast< double >(val1);
5119 }
5120 if (obj1) {
5121 ecode2 = SWIG_AsVal_double(obj1, &val2);
5122 if (!SWIG_IsOK(ecode2)) {
5123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5124 }
5125 arg2 = static_cast< double >(val2);
5126 }
5127 {
5128 PyThreadState* __tstate = wxPyBeginAllowThreads();
5129 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5130 wxPyEndAllowThreads(__tstate);
5131 if (PyErr_Occurred()) SWIG_fail;
5132 }
5133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5134 return resultobj;
5135 fail:
5136 return NULL;
5137 }
5138
5139
5140 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5141 PyObject *resultobj = 0;
5142 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5143 void *argp1 = 0 ;
5144 int res1 = 0 ;
5145 PyObject *swig_obj[1] ;
5146
5147 if (!args) SWIG_fail;
5148 swig_obj[0] = args;
5149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5150 if (!SWIG_IsOK(res1)) {
5151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5152 }
5153 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5154 {
5155 PyThreadState* __tstate = wxPyBeginAllowThreads();
5156 delete arg1;
5157
5158 wxPyEndAllowThreads(__tstate);
5159 if (PyErr_Occurred()) SWIG_fail;
5160 }
5161 resultobj = SWIG_Py_Void();
5162 return resultobj;
5163 fail:
5164 return NULL;
5165 }
5166
5167
5168 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5169 PyObject *resultobj = 0;
5170 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5171 wxRealPoint *arg2 = 0 ;
5172 bool result;
5173 void *argp1 = 0 ;
5174 int res1 = 0 ;
5175 wxRealPoint temp2 ;
5176 PyObject * obj0 = 0 ;
5177 PyObject * obj1 = 0 ;
5178 char * kwnames[] = {
5179 (char *) "self",(char *) "pt", NULL
5180 };
5181
5182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5184 if (!SWIG_IsOK(res1)) {
5185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5186 }
5187 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5188 {
5189 arg2 = &temp2;
5190 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5191 }
5192 {
5193 PyThreadState* __tstate = wxPyBeginAllowThreads();
5194 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
5195 wxPyEndAllowThreads(__tstate);
5196 if (PyErr_Occurred()) SWIG_fail;
5197 }
5198 {
5199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5200 }
5201 return resultobj;
5202 fail:
5203 return NULL;
5204 }
5205
5206
5207 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5208 PyObject *resultobj = 0;
5209 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5210 wxRealPoint *arg2 = 0 ;
5211 bool result;
5212 void *argp1 = 0 ;
5213 int res1 = 0 ;
5214 wxRealPoint temp2 ;
5215 PyObject * obj0 = 0 ;
5216 PyObject * obj1 = 0 ;
5217 char * kwnames[] = {
5218 (char *) "self",(char *) "pt", NULL
5219 };
5220
5221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5223 if (!SWIG_IsOK(res1)) {
5224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5225 }
5226 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5227 {
5228 arg2 = &temp2;
5229 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5230 }
5231 {
5232 PyThreadState* __tstate = wxPyBeginAllowThreads();
5233 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
5234 wxPyEndAllowThreads(__tstate);
5235 if (PyErr_Occurred()) SWIG_fail;
5236 }
5237 {
5238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5239 }
5240 return resultobj;
5241 fail:
5242 return NULL;
5243 }
5244
5245
5246 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5247 PyObject *resultobj = 0;
5248 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5249 wxRealPoint *arg2 = 0 ;
5250 wxRealPoint result;
5251 void *argp1 = 0 ;
5252 int res1 = 0 ;
5253 wxRealPoint temp2 ;
5254 PyObject * obj0 = 0 ;
5255 PyObject * obj1 = 0 ;
5256 char * kwnames[] = {
5257 (char *) "self",(char *) "pt", NULL
5258 };
5259
5260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5262 if (!SWIG_IsOK(res1)) {
5263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5264 }
5265 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5266 {
5267 arg2 = &temp2;
5268 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5269 }
5270 {
5271 PyThreadState* __tstate = wxPyBeginAllowThreads();
5272 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5273 wxPyEndAllowThreads(__tstate);
5274 if (PyErr_Occurred()) SWIG_fail;
5275 }
5276 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5277 return resultobj;
5278 fail:
5279 return NULL;
5280 }
5281
5282
5283 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5284 PyObject *resultobj = 0;
5285 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5286 wxRealPoint *arg2 = 0 ;
5287 wxRealPoint result;
5288 void *argp1 = 0 ;
5289 int res1 = 0 ;
5290 wxRealPoint temp2 ;
5291 PyObject * obj0 = 0 ;
5292 PyObject * obj1 = 0 ;
5293 char * kwnames[] = {
5294 (char *) "self",(char *) "pt", NULL
5295 };
5296
5297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5299 if (!SWIG_IsOK(res1)) {
5300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5301 }
5302 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5303 {
5304 arg2 = &temp2;
5305 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5306 }
5307 {
5308 PyThreadState* __tstate = wxPyBeginAllowThreads();
5309 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5310 wxPyEndAllowThreads(__tstate);
5311 if (PyErr_Occurred()) SWIG_fail;
5312 }
5313 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5314 return resultobj;
5315 fail:
5316 return NULL;
5317 }
5318
5319
5320 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5321 PyObject *resultobj = 0;
5322 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5323 double arg2 ;
5324 double arg3 ;
5325 void *argp1 = 0 ;
5326 int res1 = 0 ;
5327 double val2 ;
5328 int ecode2 = 0 ;
5329 double val3 ;
5330 int ecode3 = 0 ;
5331 PyObject * obj0 = 0 ;
5332 PyObject * obj1 = 0 ;
5333 PyObject * obj2 = 0 ;
5334 char * kwnames[] = {
5335 (char *) "self",(char *) "x",(char *) "y", NULL
5336 };
5337
5338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5340 if (!SWIG_IsOK(res1)) {
5341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5342 }
5343 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5344 ecode2 = SWIG_AsVal_double(obj1, &val2);
5345 if (!SWIG_IsOK(ecode2)) {
5346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5347 }
5348 arg2 = static_cast< double >(val2);
5349 ecode3 = SWIG_AsVal_double(obj2, &val3);
5350 if (!SWIG_IsOK(ecode3)) {
5351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5352 }
5353 arg3 = static_cast< double >(val3);
5354 {
5355 PyThreadState* __tstate = wxPyBeginAllowThreads();
5356 wxRealPoint_Set(arg1,arg2,arg3);
5357 wxPyEndAllowThreads(__tstate);
5358 if (PyErr_Occurred()) SWIG_fail;
5359 }
5360 resultobj = SWIG_Py_Void();
5361 return resultobj;
5362 fail:
5363 return NULL;
5364 }
5365
5366
5367 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5368 PyObject *resultobj = 0;
5369 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5370 PyObject *result = 0 ;
5371 void *argp1 = 0 ;
5372 int res1 = 0 ;
5373 PyObject *swig_obj[1] ;
5374
5375 if (!args) SWIG_fail;
5376 swig_obj[0] = args;
5377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5378 if (!SWIG_IsOK(res1)) {
5379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5380 }
5381 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5382 {
5383 PyThreadState* __tstate = wxPyBeginAllowThreads();
5384 result = (PyObject *)wxRealPoint_Get(arg1);
5385 wxPyEndAllowThreads(__tstate);
5386 if (PyErr_Occurred()) SWIG_fail;
5387 }
5388 resultobj = result;
5389 return resultobj;
5390 fail:
5391 return NULL;
5392 }
5393
5394
5395 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5396 PyObject *obj;
5397 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5398 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5399 return SWIG_Py_Void();
5400 }
5401
5402 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5403 return SWIG_Python_InitShadowInstance(args);
5404 }
5405
5406 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5407 PyObject *resultobj = 0;
5408 wxPoint *arg1 = (wxPoint *) 0 ;
5409 int arg2 ;
5410 void *argp1 = 0 ;
5411 int res1 = 0 ;
5412 int val2 ;
5413 int ecode2 = 0 ;
5414 PyObject *swig_obj[2] ;
5415
5416 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5418 if (!SWIG_IsOK(res1)) {
5419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5420 }
5421 arg1 = reinterpret_cast< wxPoint * >(argp1);
5422 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5423 if (!SWIG_IsOK(ecode2)) {
5424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5425 }
5426 arg2 = static_cast< int >(val2);
5427 if (arg1) (arg1)->x = arg2;
5428
5429 resultobj = SWIG_Py_Void();
5430 return resultobj;
5431 fail:
5432 return NULL;
5433 }
5434
5435
5436 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5437 PyObject *resultobj = 0;
5438 wxPoint *arg1 = (wxPoint *) 0 ;
5439 int result;
5440 void *argp1 = 0 ;
5441 int res1 = 0 ;
5442 PyObject *swig_obj[1] ;
5443
5444 if (!args) SWIG_fail;
5445 swig_obj[0] = args;
5446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5447 if (!SWIG_IsOK(res1)) {
5448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5449 }
5450 arg1 = reinterpret_cast< wxPoint * >(argp1);
5451 result = (int) ((arg1)->x);
5452 resultobj = SWIG_From_int(static_cast< int >(result));
5453 return resultobj;
5454 fail:
5455 return NULL;
5456 }
5457
5458
5459 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5460 PyObject *resultobj = 0;
5461 wxPoint *arg1 = (wxPoint *) 0 ;
5462 int arg2 ;
5463 void *argp1 = 0 ;
5464 int res1 = 0 ;
5465 int val2 ;
5466 int ecode2 = 0 ;
5467 PyObject *swig_obj[2] ;
5468
5469 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5471 if (!SWIG_IsOK(res1)) {
5472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5473 }
5474 arg1 = reinterpret_cast< wxPoint * >(argp1);
5475 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5476 if (!SWIG_IsOK(ecode2)) {
5477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5478 }
5479 arg2 = static_cast< int >(val2);
5480 if (arg1) (arg1)->y = arg2;
5481
5482 resultobj = SWIG_Py_Void();
5483 return resultobj;
5484 fail:
5485 return NULL;
5486 }
5487
5488
5489 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5490 PyObject *resultobj = 0;
5491 wxPoint *arg1 = (wxPoint *) 0 ;
5492 int result;
5493 void *argp1 = 0 ;
5494 int res1 = 0 ;
5495 PyObject *swig_obj[1] ;
5496
5497 if (!args) SWIG_fail;
5498 swig_obj[0] = args;
5499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5500 if (!SWIG_IsOK(res1)) {
5501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5502 }
5503 arg1 = reinterpret_cast< wxPoint * >(argp1);
5504 result = (int) ((arg1)->y);
5505 resultobj = SWIG_From_int(static_cast< int >(result));
5506 return resultobj;
5507 fail:
5508 return NULL;
5509 }
5510
5511
5512 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5513 PyObject *resultobj = 0;
5514 int arg1 = (int) 0 ;
5515 int arg2 = (int) 0 ;
5516 wxPoint *result = 0 ;
5517 int val1 ;
5518 int ecode1 = 0 ;
5519 int val2 ;
5520 int ecode2 = 0 ;
5521 PyObject * obj0 = 0 ;
5522 PyObject * obj1 = 0 ;
5523 char * kwnames[] = {
5524 (char *) "x",(char *) "y", NULL
5525 };
5526
5527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5528 if (obj0) {
5529 ecode1 = SWIG_AsVal_int(obj0, &val1);
5530 if (!SWIG_IsOK(ecode1)) {
5531 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5532 }
5533 arg1 = static_cast< int >(val1);
5534 }
5535 if (obj1) {
5536 ecode2 = SWIG_AsVal_int(obj1, &val2);
5537 if (!SWIG_IsOK(ecode2)) {
5538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5539 }
5540 arg2 = static_cast< int >(val2);
5541 }
5542 {
5543 PyThreadState* __tstate = wxPyBeginAllowThreads();
5544 result = (wxPoint *)new wxPoint(arg1,arg2);
5545 wxPyEndAllowThreads(__tstate);
5546 if (PyErr_Occurred()) SWIG_fail;
5547 }
5548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5549 return resultobj;
5550 fail:
5551 return NULL;
5552 }
5553
5554
5555 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5556 PyObject *resultobj = 0;
5557 wxPoint *arg1 = (wxPoint *) 0 ;
5558 void *argp1 = 0 ;
5559 int res1 = 0 ;
5560 PyObject *swig_obj[1] ;
5561
5562 if (!args) SWIG_fail;
5563 swig_obj[0] = args;
5564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5565 if (!SWIG_IsOK(res1)) {
5566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5567 }
5568 arg1 = reinterpret_cast< wxPoint * >(argp1);
5569 {
5570 PyThreadState* __tstate = wxPyBeginAllowThreads();
5571 delete arg1;
5572
5573 wxPyEndAllowThreads(__tstate);
5574 if (PyErr_Occurred()) SWIG_fail;
5575 }
5576 resultobj = SWIG_Py_Void();
5577 return resultobj;
5578 fail:
5579 return NULL;
5580 }
5581
5582
5583 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5584 PyObject *resultobj = 0;
5585 wxPoint *arg1 = (wxPoint *) 0 ;
5586 wxPoint *arg2 = 0 ;
5587 bool result;
5588 void *argp1 = 0 ;
5589 int res1 = 0 ;
5590 wxPoint temp2 ;
5591 PyObject * obj0 = 0 ;
5592 PyObject * obj1 = 0 ;
5593 char * kwnames[] = {
5594 (char *) "self",(char *) "pt", NULL
5595 };
5596
5597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5599 if (!SWIG_IsOK(res1)) {
5600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5601 }
5602 arg1 = reinterpret_cast< wxPoint * >(argp1);
5603 {
5604 arg2 = &temp2;
5605 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5606 }
5607 {
5608 PyThreadState* __tstate = wxPyBeginAllowThreads();
5609 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
5610 wxPyEndAllowThreads(__tstate);
5611 if (PyErr_Occurred()) SWIG_fail;
5612 }
5613 {
5614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5615 }
5616 return resultobj;
5617 fail:
5618 return NULL;
5619 }
5620
5621
5622 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5623 PyObject *resultobj = 0;
5624 wxPoint *arg1 = (wxPoint *) 0 ;
5625 wxPoint *arg2 = 0 ;
5626 bool result;
5627 void *argp1 = 0 ;
5628 int res1 = 0 ;
5629 wxPoint temp2 ;
5630 PyObject * obj0 = 0 ;
5631 PyObject * obj1 = 0 ;
5632 char * kwnames[] = {
5633 (char *) "self",(char *) "pt", NULL
5634 };
5635
5636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5638 if (!SWIG_IsOK(res1)) {
5639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5640 }
5641 arg1 = reinterpret_cast< wxPoint * >(argp1);
5642 {
5643 arg2 = &temp2;
5644 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5645 }
5646 {
5647 PyThreadState* __tstate = wxPyBeginAllowThreads();
5648 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
5649 wxPyEndAllowThreads(__tstate);
5650 if (PyErr_Occurred()) SWIG_fail;
5651 }
5652 {
5653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5654 }
5655 return resultobj;
5656 fail:
5657 return NULL;
5658 }
5659
5660
5661 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5662 PyObject *resultobj = 0;
5663 wxPoint *arg1 = (wxPoint *) 0 ;
5664 wxPoint *arg2 = 0 ;
5665 wxPoint result;
5666 void *argp1 = 0 ;
5667 int res1 = 0 ;
5668 wxPoint temp2 ;
5669 PyObject * obj0 = 0 ;
5670 PyObject * obj1 = 0 ;
5671 char * kwnames[] = {
5672 (char *) "self",(char *) "pt", NULL
5673 };
5674
5675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5677 if (!SWIG_IsOK(res1)) {
5678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5679 }
5680 arg1 = reinterpret_cast< wxPoint * >(argp1);
5681 {
5682 arg2 = &temp2;
5683 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5684 }
5685 {
5686 PyThreadState* __tstate = wxPyBeginAllowThreads();
5687 result = (arg1)->operator +((wxPoint const &)*arg2);
5688 wxPyEndAllowThreads(__tstate);
5689 if (PyErr_Occurred()) SWIG_fail;
5690 }
5691 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5692 return resultobj;
5693 fail:
5694 return NULL;
5695 }
5696
5697
5698 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5699 PyObject *resultobj = 0;
5700 wxPoint *arg1 = (wxPoint *) 0 ;
5701 wxPoint *arg2 = 0 ;
5702 wxPoint result;
5703 void *argp1 = 0 ;
5704 int res1 = 0 ;
5705 wxPoint temp2 ;
5706 PyObject * obj0 = 0 ;
5707 PyObject * obj1 = 0 ;
5708 char * kwnames[] = {
5709 (char *) "self",(char *) "pt", NULL
5710 };
5711
5712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5714 if (!SWIG_IsOK(res1)) {
5715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5716 }
5717 arg1 = reinterpret_cast< wxPoint * >(argp1);
5718 {
5719 arg2 = &temp2;
5720 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5721 }
5722 {
5723 PyThreadState* __tstate = wxPyBeginAllowThreads();
5724 result = (arg1)->operator -((wxPoint const &)*arg2);
5725 wxPyEndAllowThreads(__tstate);
5726 if (PyErr_Occurred()) SWIG_fail;
5727 }
5728 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5729 return resultobj;
5730 fail:
5731 return NULL;
5732 }
5733
5734
5735 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5736 PyObject *resultobj = 0;
5737 wxPoint *arg1 = (wxPoint *) 0 ;
5738 wxPoint *arg2 = 0 ;
5739 wxPoint *result = 0 ;
5740 void *argp1 = 0 ;
5741 int res1 = 0 ;
5742 wxPoint temp2 ;
5743 PyObject * obj0 = 0 ;
5744 PyObject * obj1 = 0 ;
5745 char * kwnames[] = {
5746 (char *) "self",(char *) "pt", NULL
5747 };
5748
5749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5751 if (!SWIG_IsOK(res1)) {
5752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5753 }
5754 arg1 = reinterpret_cast< wxPoint * >(argp1);
5755 {
5756 arg2 = &temp2;
5757 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5758 }
5759 {
5760 PyThreadState* __tstate = wxPyBeginAllowThreads();
5761 {
5762 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5763 result = (wxPoint *) &_result_ref;
5764 }
5765 wxPyEndAllowThreads(__tstate);
5766 if (PyErr_Occurred()) SWIG_fail;
5767 }
5768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5769 return resultobj;
5770 fail:
5771 return NULL;
5772 }
5773
5774
5775 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5776 PyObject *resultobj = 0;
5777 wxPoint *arg1 = (wxPoint *) 0 ;
5778 wxPoint *arg2 = 0 ;
5779 wxPoint *result = 0 ;
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___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5791 if (!SWIG_IsOK(res1)) {
5792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', 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 {
5802 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5803 result = (wxPoint *) &_result_ref;
5804 }
5805 wxPyEndAllowThreads(__tstate);
5806 if (PyErr_Occurred()) SWIG_fail;
5807 }
5808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5809 return resultobj;
5810 fail:
5811 return NULL;
5812 }
5813
5814
5815 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5816 PyObject *resultobj = 0;
5817 wxPoint *arg1 = (wxPoint *) 0 ;
5818 long arg2 ;
5819 long arg3 ;
5820 void *argp1 = 0 ;
5821 int res1 = 0 ;
5822 long val2 ;
5823 int ecode2 = 0 ;
5824 long val3 ;
5825 int ecode3 = 0 ;
5826 PyObject * obj0 = 0 ;
5827 PyObject * obj1 = 0 ;
5828 PyObject * obj2 = 0 ;
5829 char * kwnames[] = {
5830 (char *) "self",(char *) "x",(char *) "y", NULL
5831 };
5832
5833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5835 if (!SWIG_IsOK(res1)) {
5836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5837 }
5838 arg1 = reinterpret_cast< wxPoint * >(argp1);
5839 ecode2 = SWIG_AsVal_long(obj1, &val2);
5840 if (!SWIG_IsOK(ecode2)) {
5841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5842 }
5843 arg2 = static_cast< long >(val2);
5844 ecode3 = SWIG_AsVal_long(obj2, &val3);
5845 if (!SWIG_IsOK(ecode3)) {
5846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5847 }
5848 arg3 = static_cast< long >(val3);
5849 {
5850 PyThreadState* __tstate = wxPyBeginAllowThreads();
5851 wxPoint_Set(arg1,arg2,arg3);
5852 wxPyEndAllowThreads(__tstate);
5853 if (PyErr_Occurred()) SWIG_fail;
5854 }
5855 resultobj = SWIG_Py_Void();
5856 return resultobj;
5857 fail:
5858 return NULL;
5859 }
5860
5861
5862 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5863 PyObject *resultobj = 0;
5864 wxPoint *arg1 = (wxPoint *) 0 ;
5865 PyObject *result = 0 ;
5866 void *argp1 = 0 ;
5867 int res1 = 0 ;
5868 PyObject *swig_obj[1] ;
5869
5870 if (!args) SWIG_fail;
5871 swig_obj[0] = args;
5872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5873 if (!SWIG_IsOK(res1)) {
5874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5875 }
5876 arg1 = reinterpret_cast< wxPoint * >(argp1);
5877 {
5878 PyThreadState* __tstate = wxPyBeginAllowThreads();
5879 result = (PyObject *)wxPoint_Get(arg1);
5880 wxPyEndAllowThreads(__tstate);
5881 if (PyErr_Occurred()) SWIG_fail;
5882 }
5883 resultobj = result;
5884 return resultobj;
5885 fail:
5886 return NULL;
5887 }
5888
5889
5890 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5891 PyObject *obj;
5892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5893 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5894 return SWIG_Py_Void();
5895 }
5896
5897 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5898 return SWIG_Python_InitShadowInstance(args);
5899 }
5900
5901 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5902 PyObject *resultobj = 0;
5903 int arg1 = (int) 0 ;
5904 int arg2 = (int) 0 ;
5905 int arg3 = (int) 0 ;
5906 int arg4 = (int) 0 ;
5907 wxRect *result = 0 ;
5908 int val1 ;
5909 int ecode1 = 0 ;
5910 int val2 ;
5911 int ecode2 = 0 ;
5912 int val3 ;
5913 int ecode3 = 0 ;
5914 int val4 ;
5915 int ecode4 = 0 ;
5916 PyObject * obj0 = 0 ;
5917 PyObject * obj1 = 0 ;
5918 PyObject * obj2 = 0 ;
5919 PyObject * obj3 = 0 ;
5920 char * kwnames[] = {
5921 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
5922 };
5923
5924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5925 if (obj0) {
5926 ecode1 = SWIG_AsVal_int(obj0, &val1);
5927 if (!SWIG_IsOK(ecode1)) {
5928 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
5929 }
5930 arg1 = static_cast< int >(val1);
5931 }
5932 if (obj1) {
5933 ecode2 = SWIG_AsVal_int(obj1, &val2);
5934 if (!SWIG_IsOK(ecode2)) {
5935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
5936 }
5937 arg2 = static_cast< int >(val2);
5938 }
5939 if (obj2) {
5940 ecode3 = SWIG_AsVal_int(obj2, &val3);
5941 if (!SWIG_IsOK(ecode3)) {
5942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
5943 }
5944 arg3 = static_cast< int >(val3);
5945 }
5946 if (obj3) {
5947 ecode4 = SWIG_AsVal_int(obj3, &val4);
5948 if (!SWIG_IsOK(ecode4)) {
5949 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
5950 }
5951 arg4 = static_cast< int >(val4);
5952 }
5953 {
5954 PyThreadState* __tstate = wxPyBeginAllowThreads();
5955 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
5956 wxPyEndAllowThreads(__tstate);
5957 if (PyErr_Occurred()) SWIG_fail;
5958 }
5959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
5960 return resultobj;
5961 fail:
5962 return NULL;
5963 }
5964
5965
5966 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5967 PyObject *resultobj = 0;
5968 wxPoint *arg1 = 0 ;
5969 wxPoint *arg2 = 0 ;
5970 wxRect *result = 0 ;
5971 wxPoint temp1 ;
5972 wxPoint temp2 ;
5973 PyObject * obj0 = 0 ;
5974 PyObject * obj1 = 0 ;
5975 char * kwnames[] = {
5976 (char *) "topLeft",(char *) "bottomRight", NULL
5977 };
5978
5979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
5980 {
5981 arg1 = &temp1;
5982 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5983 }
5984 {
5985 arg2 = &temp2;
5986 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5987 }
5988 {
5989 PyThreadState* __tstate = wxPyBeginAllowThreads();
5990 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
5995 return resultobj;
5996 fail:
5997 return NULL;
5998 }
5999
6000
6001 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6002 PyObject *resultobj = 0;
6003 wxPoint *arg1 = 0 ;
6004 wxSize *arg2 = 0 ;
6005 wxRect *result = 0 ;
6006 wxPoint temp1 ;
6007 wxSize temp2 ;
6008 PyObject * obj0 = 0 ;
6009 PyObject * obj1 = 0 ;
6010 char * kwnames[] = {
6011 (char *) "pos",(char *) "size", NULL
6012 };
6013
6014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6015 {
6016 arg1 = &temp1;
6017 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6018 }
6019 {
6020 arg2 = &temp2;
6021 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6022 }
6023 {
6024 PyThreadState* __tstate = wxPyBeginAllowThreads();
6025 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6026 wxPyEndAllowThreads(__tstate);
6027 if (PyErr_Occurred()) SWIG_fail;
6028 }
6029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6030 return resultobj;
6031 fail:
6032 return NULL;
6033 }
6034
6035
6036 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6037 PyObject *resultobj = 0;
6038 wxSize *arg1 = 0 ;
6039 wxRect *result = 0 ;
6040 wxSize temp1 ;
6041 PyObject * obj0 = 0 ;
6042 char * kwnames[] = {
6043 (char *) "size", NULL
6044 };
6045
6046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6047 {
6048 arg1 = &temp1;
6049 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6050 }
6051 {
6052 PyThreadState* __tstate = wxPyBeginAllowThreads();
6053 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6054 wxPyEndAllowThreads(__tstate);
6055 if (PyErr_Occurred()) SWIG_fail;
6056 }
6057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6058 return resultobj;
6059 fail:
6060 return NULL;
6061 }
6062
6063
6064 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6065 PyObject *resultobj = 0;
6066 wxRect *arg1 = (wxRect *) 0 ;
6067 void *argp1 = 0 ;
6068 int res1 = 0 ;
6069 PyObject *swig_obj[1] ;
6070
6071 if (!args) SWIG_fail;
6072 swig_obj[0] = args;
6073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6074 if (!SWIG_IsOK(res1)) {
6075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6076 }
6077 arg1 = reinterpret_cast< wxRect * >(argp1);
6078 {
6079 PyThreadState* __tstate = wxPyBeginAllowThreads();
6080 delete arg1;
6081
6082 wxPyEndAllowThreads(__tstate);
6083 if (PyErr_Occurred()) SWIG_fail;
6084 }
6085 resultobj = SWIG_Py_Void();
6086 return resultobj;
6087 fail:
6088 return NULL;
6089 }
6090
6091
6092 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6093 PyObject *resultobj = 0;
6094 wxRect *arg1 = (wxRect *) 0 ;
6095 int result;
6096 void *argp1 = 0 ;
6097 int res1 = 0 ;
6098 PyObject *swig_obj[1] ;
6099
6100 if (!args) SWIG_fail;
6101 swig_obj[0] = args;
6102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6103 if (!SWIG_IsOK(res1)) {
6104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6105 }
6106 arg1 = reinterpret_cast< wxRect * >(argp1);
6107 {
6108 PyThreadState* __tstate = wxPyBeginAllowThreads();
6109 result = (int)((wxRect const *)arg1)->GetX();
6110 wxPyEndAllowThreads(__tstate);
6111 if (PyErr_Occurred()) SWIG_fail;
6112 }
6113 resultobj = SWIG_From_int(static_cast< int >(result));
6114 return resultobj;
6115 fail:
6116 return NULL;
6117 }
6118
6119
6120 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6121 PyObject *resultobj = 0;
6122 wxRect *arg1 = (wxRect *) 0 ;
6123 int arg2 ;
6124 void *argp1 = 0 ;
6125 int res1 = 0 ;
6126 int val2 ;
6127 int ecode2 = 0 ;
6128 PyObject * obj0 = 0 ;
6129 PyObject * obj1 = 0 ;
6130 char * kwnames[] = {
6131 (char *) "self",(char *) "x", NULL
6132 };
6133
6134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6136 if (!SWIG_IsOK(res1)) {
6137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6138 }
6139 arg1 = reinterpret_cast< wxRect * >(argp1);
6140 ecode2 = SWIG_AsVal_int(obj1, &val2);
6141 if (!SWIG_IsOK(ecode2)) {
6142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6143 }
6144 arg2 = static_cast< int >(val2);
6145 {
6146 PyThreadState* __tstate = wxPyBeginAllowThreads();
6147 (arg1)->SetX(arg2);
6148 wxPyEndAllowThreads(__tstate);
6149 if (PyErr_Occurred()) SWIG_fail;
6150 }
6151 resultobj = SWIG_Py_Void();
6152 return resultobj;
6153 fail:
6154 return NULL;
6155 }
6156
6157
6158 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6159 PyObject *resultobj = 0;
6160 wxRect *arg1 = (wxRect *) 0 ;
6161 int result;
6162 void *argp1 = 0 ;
6163 int res1 = 0 ;
6164 PyObject *swig_obj[1] ;
6165
6166 if (!args) SWIG_fail;
6167 swig_obj[0] = args;
6168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6169 if (!SWIG_IsOK(res1)) {
6170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6171 }
6172 arg1 = reinterpret_cast< wxRect * >(argp1);
6173 {
6174 PyThreadState* __tstate = wxPyBeginAllowThreads();
6175 result = (int)(arg1)->GetY();
6176 wxPyEndAllowThreads(__tstate);
6177 if (PyErr_Occurred()) SWIG_fail;
6178 }
6179 resultobj = SWIG_From_int(static_cast< int >(result));
6180 return resultobj;
6181 fail:
6182 return NULL;
6183 }
6184
6185
6186 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6187 PyObject *resultobj = 0;
6188 wxRect *arg1 = (wxRect *) 0 ;
6189 int arg2 ;
6190 void *argp1 = 0 ;
6191 int res1 = 0 ;
6192 int val2 ;
6193 int ecode2 = 0 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 char * kwnames[] = {
6197 (char *) "self",(char *) "y", NULL
6198 };
6199
6200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6202 if (!SWIG_IsOK(res1)) {
6203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6204 }
6205 arg1 = reinterpret_cast< wxRect * >(argp1);
6206 ecode2 = SWIG_AsVal_int(obj1, &val2);
6207 if (!SWIG_IsOK(ecode2)) {
6208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6209 }
6210 arg2 = static_cast< int >(val2);
6211 {
6212 PyThreadState* __tstate = wxPyBeginAllowThreads();
6213 (arg1)->SetY(arg2);
6214 wxPyEndAllowThreads(__tstate);
6215 if (PyErr_Occurred()) SWIG_fail;
6216 }
6217 resultobj = SWIG_Py_Void();
6218 return resultobj;
6219 fail:
6220 return NULL;
6221 }
6222
6223
6224 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6225 PyObject *resultobj = 0;
6226 wxRect *arg1 = (wxRect *) 0 ;
6227 int result;
6228 void *argp1 = 0 ;
6229 int res1 = 0 ;
6230 PyObject *swig_obj[1] ;
6231
6232 if (!args) SWIG_fail;
6233 swig_obj[0] = args;
6234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6235 if (!SWIG_IsOK(res1)) {
6236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6237 }
6238 arg1 = reinterpret_cast< wxRect * >(argp1);
6239 {
6240 PyThreadState* __tstate = wxPyBeginAllowThreads();
6241 result = (int)((wxRect const *)arg1)->GetWidth();
6242 wxPyEndAllowThreads(__tstate);
6243 if (PyErr_Occurred()) SWIG_fail;
6244 }
6245 resultobj = SWIG_From_int(static_cast< int >(result));
6246 return resultobj;
6247 fail:
6248 return NULL;
6249 }
6250
6251
6252 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6253 PyObject *resultobj = 0;
6254 wxRect *arg1 = (wxRect *) 0 ;
6255 int arg2 ;
6256 void *argp1 = 0 ;
6257 int res1 = 0 ;
6258 int val2 ;
6259 int ecode2 = 0 ;
6260 PyObject * obj0 = 0 ;
6261 PyObject * obj1 = 0 ;
6262 char * kwnames[] = {
6263 (char *) "self",(char *) "w", NULL
6264 };
6265
6266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6268 if (!SWIG_IsOK(res1)) {
6269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6270 }
6271 arg1 = reinterpret_cast< wxRect * >(argp1);
6272 ecode2 = SWIG_AsVal_int(obj1, &val2);
6273 if (!SWIG_IsOK(ecode2)) {
6274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6275 }
6276 arg2 = static_cast< int >(val2);
6277 {
6278 PyThreadState* __tstate = wxPyBeginAllowThreads();
6279 (arg1)->SetWidth(arg2);
6280 wxPyEndAllowThreads(__tstate);
6281 if (PyErr_Occurred()) SWIG_fail;
6282 }
6283 resultobj = SWIG_Py_Void();
6284 return resultobj;
6285 fail:
6286 return NULL;
6287 }
6288
6289
6290 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6291 PyObject *resultobj = 0;
6292 wxRect *arg1 = (wxRect *) 0 ;
6293 int result;
6294 void *argp1 = 0 ;
6295 int res1 = 0 ;
6296 PyObject *swig_obj[1] ;
6297
6298 if (!args) SWIG_fail;
6299 swig_obj[0] = args;
6300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6301 if (!SWIG_IsOK(res1)) {
6302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6303 }
6304 arg1 = reinterpret_cast< wxRect * >(argp1);
6305 {
6306 PyThreadState* __tstate = wxPyBeginAllowThreads();
6307 result = (int)((wxRect const *)arg1)->GetHeight();
6308 wxPyEndAllowThreads(__tstate);
6309 if (PyErr_Occurred()) SWIG_fail;
6310 }
6311 resultobj = SWIG_From_int(static_cast< int >(result));
6312 return resultobj;
6313 fail:
6314 return NULL;
6315 }
6316
6317
6318 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6319 PyObject *resultobj = 0;
6320 wxRect *arg1 = (wxRect *) 0 ;
6321 int arg2 ;
6322 void *argp1 = 0 ;
6323 int res1 = 0 ;
6324 int val2 ;
6325 int ecode2 = 0 ;
6326 PyObject * obj0 = 0 ;
6327 PyObject * obj1 = 0 ;
6328 char * kwnames[] = {
6329 (char *) "self",(char *) "h", NULL
6330 };
6331
6332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6334 if (!SWIG_IsOK(res1)) {
6335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6336 }
6337 arg1 = reinterpret_cast< wxRect * >(argp1);
6338 ecode2 = SWIG_AsVal_int(obj1, &val2);
6339 if (!SWIG_IsOK(ecode2)) {
6340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6341 }
6342 arg2 = static_cast< int >(val2);
6343 {
6344 PyThreadState* __tstate = wxPyBeginAllowThreads();
6345 (arg1)->SetHeight(arg2);
6346 wxPyEndAllowThreads(__tstate);
6347 if (PyErr_Occurred()) SWIG_fail;
6348 }
6349 resultobj = SWIG_Py_Void();
6350 return resultobj;
6351 fail:
6352 return NULL;
6353 }
6354
6355
6356 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6357 PyObject *resultobj = 0;
6358 wxRect *arg1 = (wxRect *) 0 ;
6359 wxPoint result;
6360 void *argp1 = 0 ;
6361 int res1 = 0 ;
6362 PyObject *swig_obj[1] ;
6363
6364 if (!args) SWIG_fail;
6365 swig_obj[0] = args;
6366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6367 if (!SWIG_IsOK(res1)) {
6368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6369 }
6370 arg1 = reinterpret_cast< wxRect * >(argp1);
6371 {
6372 PyThreadState* __tstate = wxPyBeginAllowThreads();
6373 result = ((wxRect const *)arg1)->GetPosition();
6374 wxPyEndAllowThreads(__tstate);
6375 if (PyErr_Occurred()) SWIG_fail;
6376 }
6377 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6378 return resultobj;
6379 fail:
6380 return NULL;
6381 }
6382
6383
6384 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6385 PyObject *resultobj = 0;
6386 wxRect *arg1 = (wxRect *) 0 ;
6387 wxPoint *arg2 = 0 ;
6388 void *argp1 = 0 ;
6389 int res1 = 0 ;
6390 wxPoint temp2 ;
6391 PyObject * obj0 = 0 ;
6392 PyObject * obj1 = 0 ;
6393 char * kwnames[] = {
6394 (char *) "self",(char *) "p", NULL
6395 };
6396
6397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6399 if (!SWIG_IsOK(res1)) {
6400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6401 }
6402 arg1 = reinterpret_cast< wxRect * >(argp1);
6403 {
6404 arg2 = &temp2;
6405 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6406 }
6407 {
6408 PyThreadState* __tstate = wxPyBeginAllowThreads();
6409 (arg1)->SetPosition((wxPoint const &)*arg2);
6410 wxPyEndAllowThreads(__tstate);
6411 if (PyErr_Occurred()) SWIG_fail;
6412 }
6413 resultobj = SWIG_Py_Void();
6414 return resultobj;
6415 fail:
6416 return NULL;
6417 }
6418
6419
6420 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6421 PyObject *resultobj = 0;
6422 wxRect *arg1 = (wxRect *) 0 ;
6423 wxSize result;
6424 void *argp1 = 0 ;
6425 int res1 = 0 ;
6426 PyObject *swig_obj[1] ;
6427
6428 if (!args) SWIG_fail;
6429 swig_obj[0] = args;
6430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6431 if (!SWIG_IsOK(res1)) {
6432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6433 }
6434 arg1 = reinterpret_cast< wxRect * >(argp1);
6435 {
6436 PyThreadState* __tstate = wxPyBeginAllowThreads();
6437 result = ((wxRect const *)arg1)->GetSize();
6438 wxPyEndAllowThreads(__tstate);
6439 if (PyErr_Occurred()) SWIG_fail;
6440 }
6441 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6442 return resultobj;
6443 fail:
6444 return NULL;
6445 }
6446
6447
6448 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6449 PyObject *resultobj = 0;
6450 wxRect *arg1 = (wxRect *) 0 ;
6451 wxSize *arg2 = 0 ;
6452 void *argp1 = 0 ;
6453 int res1 = 0 ;
6454 wxSize temp2 ;
6455 PyObject * obj0 = 0 ;
6456 PyObject * obj1 = 0 ;
6457 char * kwnames[] = {
6458 (char *) "self",(char *) "s", NULL
6459 };
6460
6461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6463 if (!SWIG_IsOK(res1)) {
6464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6465 }
6466 arg1 = reinterpret_cast< wxRect * >(argp1);
6467 {
6468 arg2 = &temp2;
6469 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6470 }
6471 {
6472 PyThreadState* __tstate = wxPyBeginAllowThreads();
6473 (arg1)->SetSize((wxSize const &)*arg2);
6474 wxPyEndAllowThreads(__tstate);
6475 if (PyErr_Occurred()) SWIG_fail;
6476 }
6477 resultobj = SWIG_Py_Void();
6478 return resultobj;
6479 fail:
6480 return NULL;
6481 }
6482
6483
6484 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6485 PyObject *resultobj = 0;
6486 wxRect *arg1 = (wxRect *) 0 ;
6487 bool result;
6488 void *argp1 = 0 ;
6489 int res1 = 0 ;
6490 PyObject *swig_obj[1] ;
6491
6492 if (!args) SWIG_fail;
6493 swig_obj[0] = args;
6494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6495 if (!SWIG_IsOK(res1)) {
6496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6497 }
6498 arg1 = reinterpret_cast< wxRect * >(argp1);
6499 {
6500 PyThreadState* __tstate = wxPyBeginAllowThreads();
6501 result = (bool)((wxRect const *)arg1)->IsEmpty();
6502 wxPyEndAllowThreads(__tstate);
6503 if (PyErr_Occurred()) SWIG_fail;
6504 }
6505 {
6506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6507 }
6508 return resultobj;
6509 fail:
6510 return NULL;
6511 }
6512
6513
6514 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6515 PyObject *resultobj = 0;
6516 wxRect *arg1 = (wxRect *) 0 ;
6517 wxPoint result;
6518 void *argp1 = 0 ;
6519 int res1 = 0 ;
6520 PyObject *swig_obj[1] ;
6521
6522 if (!args) SWIG_fail;
6523 swig_obj[0] = args;
6524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6525 if (!SWIG_IsOK(res1)) {
6526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6527 }
6528 arg1 = reinterpret_cast< wxRect * >(argp1);
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 result = ((wxRect const *)arg1)->GetTopLeft();
6532 wxPyEndAllowThreads(__tstate);
6533 if (PyErr_Occurred()) SWIG_fail;
6534 }
6535 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6536 return resultobj;
6537 fail:
6538 return NULL;
6539 }
6540
6541
6542 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6543 PyObject *resultobj = 0;
6544 wxRect *arg1 = (wxRect *) 0 ;
6545 wxPoint *arg2 = 0 ;
6546 void *argp1 = 0 ;
6547 int res1 = 0 ;
6548 wxPoint temp2 ;
6549 PyObject * obj0 = 0 ;
6550 PyObject * obj1 = 0 ;
6551 char * kwnames[] = {
6552 (char *) "self",(char *) "p", NULL
6553 };
6554
6555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6557 if (!SWIG_IsOK(res1)) {
6558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6559 }
6560 arg1 = reinterpret_cast< wxRect * >(argp1);
6561 {
6562 arg2 = &temp2;
6563 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6564 }
6565 {
6566 PyThreadState* __tstate = wxPyBeginAllowThreads();
6567 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6568 wxPyEndAllowThreads(__tstate);
6569 if (PyErr_Occurred()) SWIG_fail;
6570 }
6571 resultobj = SWIG_Py_Void();
6572 return resultobj;
6573 fail:
6574 return NULL;
6575 }
6576
6577
6578 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6579 PyObject *resultobj = 0;
6580 wxRect *arg1 = (wxRect *) 0 ;
6581 wxPoint result;
6582 void *argp1 = 0 ;
6583 int res1 = 0 ;
6584 PyObject *swig_obj[1] ;
6585
6586 if (!args) SWIG_fail;
6587 swig_obj[0] = args;
6588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6589 if (!SWIG_IsOK(res1)) {
6590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6591 }
6592 arg1 = reinterpret_cast< wxRect * >(argp1);
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 result = ((wxRect const *)arg1)->GetBottomRight();
6596 wxPyEndAllowThreads(__tstate);
6597 if (PyErr_Occurred()) SWIG_fail;
6598 }
6599 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6600 return resultobj;
6601 fail:
6602 return NULL;
6603 }
6604
6605
6606 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6607 PyObject *resultobj = 0;
6608 wxRect *arg1 = (wxRect *) 0 ;
6609 wxPoint *arg2 = 0 ;
6610 void *argp1 = 0 ;
6611 int res1 = 0 ;
6612 wxPoint temp2 ;
6613 PyObject * obj0 = 0 ;
6614 PyObject * obj1 = 0 ;
6615 char * kwnames[] = {
6616 (char *) "self",(char *) "p", NULL
6617 };
6618
6619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6621 if (!SWIG_IsOK(res1)) {
6622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6623 }
6624 arg1 = reinterpret_cast< wxRect * >(argp1);
6625 {
6626 arg2 = &temp2;
6627 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6628 }
6629 {
6630 PyThreadState* __tstate = wxPyBeginAllowThreads();
6631 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6632 wxPyEndAllowThreads(__tstate);
6633 if (PyErr_Occurred()) SWIG_fail;
6634 }
6635 resultobj = SWIG_Py_Void();
6636 return resultobj;
6637 fail:
6638 return NULL;
6639 }
6640
6641
6642 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6643 PyObject *resultobj = 0;
6644 wxRect *arg1 = (wxRect *) 0 ;
6645 int result;
6646 void *argp1 = 0 ;
6647 int res1 = 0 ;
6648 PyObject *swig_obj[1] ;
6649
6650 if (!args) SWIG_fail;
6651 swig_obj[0] = args;
6652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6653 if (!SWIG_IsOK(res1)) {
6654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6655 }
6656 arg1 = reinterpret_cast< wxRect * >(argp1);
6657 {
6658 PyThreadState* __tstate = wxPyBeginAllowThreads();
6659 result = (int)((wxRect const *)arg1)->GetLeft();
6660 wxPyEndAllowThreads(__tstate);
6661 if (PyErr_Occurred()) SWIG_fail;
6662 }
6663 resultobj = SWIG_From_int(static_cast< int >(result));
6664 return resultobj;
6665 fail:
6666 return NULL;
6667 }
6668
6669
6670 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6671 PyObject *resultobj = 0;
6672 wxRect *arg1 = (wxRect *) 0 ;
6673 int result;
6674 void *argp1 = 0 ;
6675 int res1 = 0 ;
6676 PyObject *swig_obj[1] ;
6677
6678 if (!args) SWIG_fail;
6679 swig_obj[0] = args;
6680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6681 if (!SWIG_IsOK(res1)) {
6682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6683 }
6684 arg1 = reinterpret_cast< wxRect * >(argp1);
6685 {
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = (int)((wxRect const *)arg1)->GetTop();
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 resultobj = SWIG_From_int(static_cast< int >(result));
6692 return resultobj;
6693 fail:
6694 return NULL;
6695 }
6696
6697
6698 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6699 PyObject *resultobj = 0;
6700 wxRect *arg1 = (wxRect *) 0 ;
6701 int result;
6702 void *argp1 = 0 ;
6703 int res1 = 0 ;
6704 PyObject *swig_obj[1] ;
6705
6706 if (!args) SWIG_fail;
6707 swig_obj[0] = args;
6708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6709 if (!SWIG_IsOK(res1)) {
6710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6711 }
6712 arg1 = reinterpret_cast< wxRect * >(argp1);
6713 {
6714 PyThreadState* __tstate = wxPyBeginAllowThreads();
6715 result = (int)((wxRect const *)arg1)->GetBottom();
6716 wxPyEndAllowThreads(__tstate);
6717 if (PyErr_Occurred()) SWIG_fail;
6718 }
6719 resultobj = SWIG_From_int(static_cast< int >(result));
6720 return resultobj;
6721 fail:
6722 return NULL;
6723 }
6724
6725
6726 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6727 PyObject *resultobj = 0;
6728 wxRect *arg1 = (wxRect *) 0 ;
6729 int result;
6730 void *argp1 = 0 ;
6731 int res1 = 0 ;
6732 PyObject *swig_obj[1] ;
6733
6734 if (!args) SWIG_fail;
6735 swig_obj[0] = args;
6736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6737 if (!SWIG_IsOK(res1)) {
6738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6739 }
6740 arg1 = reinterpret_cast< wxRect * >(argp1);
6741 {
6742 PyThreadState* __tstate = wxPyBeginAllowThreads();
6743 result = (int)((wxRect const *)arg1)->GetRight();
6744 wxPyEndAllowThreads(__tstate);
6745 if (PyErr_Occurred()) SWIG_fail;
6746 }
6747 resultobj = SWIG_From_int(static_cast< int >(result));
6748 return resultobj;
6749 fail:
6750 return NULL;
6751 }
6752
6753
6754 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6755 PyObject *resultobj = 0;
6756 wxRect *arg1 = (wxRect *) 0 ;
6757 int arg2 ;
6758 void *argp1 = 0 ;
6759 int res1 = 0 ;
6760 int val2 ;
6761 int ecode2 = 0 ;
6762 PyObject * obj0 = 0 ;
6763 PyObject * obj1 = 0 ;
6764 char * kwnames[] = {
6765 (char *) "self",(char *) "left", NULL
6766 };
6767
6768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6770 if (!SWIG_IsOK(res1)) {
6771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6772 }
6773 arg1 = reinterpret_cast< wxRect * >(argp1);
6774 ecode2 = SWIG_AsVal_int(obj1, &val2);
6775 if (!SWIG_IsOK(ecode2)) {
6776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6777 }
6778 arg2 = static_cast< int >(val2);
6779 {
6780 PyThreadState* __tstate = wxPyBeginAllowThreads();
6781 (arg1)->SetLeft(arg2);
6782 wxPyEndAllowThreads(__tstate);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 resultobj = SWIG_Py_Void();
6786 return resultobj;
6787 fail:
6788 return NULL;
6789 }
6790
6791
6792 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6793 PyObject *resultobj = 0;
6794 wxRect *arg1 = (wxRect *) 0 ;
6795 int arg2 ;
6796 void *argp1 = 0 ;
6797 int res1 = 0 ;
6798 int val2 ;
6799 int ecode2 = 0 ;
6800 PyObject * obj0 = 0 ;
6801 PyObject * obj1 = 0 ;
6802 char * kwnames[] = {
6803 (char *) "self",(char *) "right", NULL
6804 };
6805
6806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6808 if (!SWIG_IsOK(res1)) {
6809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6810 }
6811 arg1 = reinterpret_cast< wxRect * >(argp1);
6812 ecode2 = SWIG_AsVal_int(obj1, &val2);
6813 if (!SWIG_IsOK(ecode2)) {
6814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6815 }
6816 arg2 = static_cast< int >(val2);
6817 {
6818 PyThreadState* __tstate = wxPyBeginAllowThreads();
6819 (arg1)->SetRight(arg2);
6820 wxPyEndAllowThreads(__tstate);
6821 if (PyErr_Occurred()) SWIG_fail;
6822 }
6823 resultobj = SWIG_Py_Void();
6824 return resultobj;
6825 fail:
6826 return NULL;
6827 }
6828
6829
6830 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6831 PyObject *resultobj = 0;
6832 wxRect *arg1 = (wxRect *) 0 ;
6833 int arg2 ;
6834 void *argp1 = 0 ;
6835 int res1 = 0 ;
6836 int val2 ;
6837 int ecode2 = 0 ;
6838 PyObject * obj0 = 0 ;
6839 PyObject * obj1 = 0 ;
6840 char * kwnames[] = {
6841 (char *) "self",(char *) "top", NULL
6842 };
6843
6844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6846 if (!SWIG_IsOK(res1)) {
6847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6848 }
6849 arg1 = reinterpret_cast< wxRect * >(argp1);
6850 ecode2 = SWIG_AsVal_int(obj1, &val2);
6851 if (!SWIG_IsOK(ecode2)) {
6852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6853 }
6854 arg2 = static_cast< int >(val2);
6855 {
6856 PyThreadState* __tstate = wxPyBeginAllowThreads();
6857 (arg1)->SetTop(arg2);
6858 wxPyEndAllowThreads(__tstate);
6859 if (PyErr_Occurred()) SWIG_fail;
6860 }
6861 resultobj = SWIG_Py_Void();
6862 return resultobj;
6863 fail:
6864 return NULL;
6865 }
6866
6867
6868 SWIGINTERN PyObject *_wrap_Rect_SetBottom(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 *) "bottom", NULL
6880 };
6881
6882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",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_SetBottom" "', 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_SetBottom" "', expected argument " "2"" of type '" "int""'");
6891 }
6892 arg2 = static_cast< int >(val2);
6893 {
6894 PyThreadState* __tstate = wxPyBeginAllowThreads();
6895 (arg1)->SetBottom(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_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6907 PyObject *resultobj = 0;
6908 wxRect *arg1 = (wxRect *) 0 ;
6909 int arg2 ;
6910 int arg3 ;
6911 wxRect *result = 0 ;
6912 void *argp1 = 0 ;
6913 int res1 = 0 ;
6914 int val2 ;
6915 int ecode2 = 0 ;
6916 int val3 ;
6917 int ecode3 = 0 ;
6918 PyObject * obj0 = 0 ;
6919 PyObject * obj1 = 0 ;
6920 PyObject * obj2 = 0 ;
6921 char * kwnames[] = {
6922 (char *) "self",(char *) "dx",(char *) "dy", NULL
6923 };
6924
6925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6927 if (!SWIG_IsOK(res1)) {
6928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
6929 }
6930 arg1 = reinterpret_cast< wxRect * >(argp1);
6931 ecode2 = SWIG_AsVal_int(obj1, &val2);
6932 if (!SWIG_IsOK(ecode2)) {
6933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
6934 }
6935 arg2 = static_cast< int >(val2);
6936 ecode3 = SWIG_AsVal_int(obj2, &val3);
6937 if (!SWIG_IsOK(ecode3)) {
6938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
6939 }
6940 arg3 = static_cast< int >(val3);
6941 {
6942 PyThreadState* __tstate = wxPyBeginAllowThreads();
6943 {
6944 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
6945 result = (wxRect *) &_result_ref;
6946 }
6947 wxPyEndAllowThreads(__tstate);
6948 if (PyErr_Occurred()) SWIG_fail;
6949 }
6950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
6951 return resultobj;
6952 fail:
6953 return NULL;
6954 }
6955
6956
6957 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6958 PyObject *resultobj = 0;
6959 wxRect *arg1 = (wxRect *) 0 ;
6960 int arg2 ;
6961 int arg3 ;
6962 wxRect *result = 0 ;
6963 void *argp1 = 0 ;
6964 int res1 = 0 ;
6965 int val2 ;
6966 int ecode2 = 0 ;
6967 int val3 ;
6968 int ecode3 = 0 ;
6969 PyObject * obj0 = 0 ;
6970 PyObject * obj1 = 0 ;
6971 PyObject * obj2 = 0 ;
6972 char * kwnames[] = {
6973 (char *) "self",(char *) "dx",(char *) "dy", NULL
6974 };
6975
6976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6978 if (!SWIG_IsOK(res1)) {
6979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
6980 }
6981 arg1 = reinterpret_cast< wxRect * >(argp1);
6982 ecode2 = SWIG_AsVal_int(obj1, &val2);
6983 if (!SWIG_IsOK(ecode2)) {
6984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
6985 }
6986 arg2 = static_cast< int >(val2);
6987 ecode3 = SWIG_AsVal_int(obj2, &val3);
6988 if (!SWIG_IsOK(ecode3)) {
6989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
6990 }
6991 arg3 = static_cast< int >(val3);
6992 {
6993 PyThreadState* __tstate = wxPyBeginAllowThreads();
6994 {
6995 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
6996 result = (wxRect *) &_result_ref;
6997 }
6998 wxPyEndAllowThreads(__tstate);
6999 if (PyErr_Occurred()) SWIG_fail;
7000 }
7001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7002 return resultobj;
7003 fail:
7004 return NULL;
7005 }
7006
7007
7008 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7009 PyObject *resultobj = 0;
7010 wxRect *arg1 = (wxRect *) 0 ;
7011 int arg2 ;
7012 int arg3 ;
7013 void *argp1 = 0 ;
7014 int res1 = 0 ;
7015 int val2 ;
7016 int ecode2 = 0 ;
7017 int val3 ;
7018 int ecode3 = 0 ;
7019 PyObject * obj0 = 0 ;
7020 PyObject * obj1 = 0 ;
7021 PyObject * obj2 = 0 ;
7022 char * kwnames[] = {
7023 (char *) "self",(char *) "dx",(char *) "dy", NULL
7024 };
7025
7026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7028 if (!SWIG_IsOK(res1)) {
7029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7030 }
7031 arg1 = reinterpret_cast< wxRect * >(argp1);
7032 ecode2 = SWIG_AsVal_int(obj1, &val2);
7033 if (!SWIG_IsOK(ecode2)) {
7034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7035 }
7036 arg2 = static_cast< int >(val2);
7037 ecode3 = SWIG_AsVal_int(obj2, &val3);
7038 if (!SWIG_IsOK(ecode3)) {
7039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7040 }
7041 arg3 = static_cast< int >(val3);
7042 {
7043 PyThreadState* __tstate = wxPyBeginAllowThreads();
7044 (arg1)->Offset(arg2,arg3);
7045 wxPyEndAllowThreads(__tstate);
7046 if (PyErr_Occurred()) SWIG_fail;
7047 }
7048 resultobj = SWIG_Py_Void();
7049 return resultobj;
7050 fail:
7051 return NULL;
7052 }
7053
7054
7055 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7056 PyObject *resultobj = 0;
7057 wxRect *arg1 = (wxRect *) 0 ;
7058 wxPoint *arg2 = 0 ;
7059 void *argp1 = 0 ;
7060 int res1 = 0 ;
7061 wxPoint temp2 ;
7062 PyObject * obj0 = 0 ;
7063 PyObject * obj1 = 0 ;
7064 char * kwnames[] = {
7065 (char *) "self",(char *) "pt", NULL
7066 };
7067
7068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7070 if (!SWIG_IsOK(res1)) {
7071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7072 }
7073 arg1 = reinterpret_cast< wxRect * >(argp1);
7074 {
7075 arg2 = &temp2;
7076 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7077 }
7078 {
7079 PyThreadState* __tstate = wxPyBeginAllowThreads();
7080 (arg1)->Offset((wxPoint const &)*arg2);
7081 wxPyEndAllowThreads(__tstate);
7082 if (PyErr_Occurred()) SWIG_fail;
7083 }
7084 resultobj = SWIG_Py_Void();
7085 return resultobj;
7086 fail:
7087 return NULL;
7088 }
7089
7090
7091 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7092 PyObject *resultobj = 0;
7093 wxRect *arg1 = (wxRect *) 0 ;
7094 wxRect *arg2 = 0 ;
7095 wxRect result;
7096 void *argp1 = 0 ;
7097 int res1 = 0 ;
7098 wxRect temp2 ;
7099 PyObject * obj0 = 0 ;
7100 PyObject * obj1 = 0 ;
7101 char * kwnames[] = {
7102 (char *) "self",(char *) "rect", NULL
7103 };
7104
7105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7107 if (!SWIG_IsOK(res1)) {
7108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7109 }
7110 arg1 = reinterpret_cast< wxRect * >(argp1);
7111 {
7112 arg2 = &temp2;
7113 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7114 }
7115 {
7116 PyThreadState* __tstate = wxPyBeginAllowThreads();
7117 result = (arg1)->Intersect((wxRect const &)*arg2);
7118 wxPyEndAllowThreads(__tstate);
7119 if (PyErr_Occurred()) SWIG_fail;
7120 }
7121 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7122 return resultobj;
7123 fail:
7124 return NULL;
7125 }
7126
7127
7128 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7129 PyObject *resultobj = 0;
7130 wxRect *arg1 = (wxRect *) 0 ;
7131 wxRect *arg2 = 0 ;
7132 wxRect result;
7133 void *argp1 = 0 ;
7134 int res1 = 0 ;
7135 wxRect temp2 ;
7136 PyObject * obj0 = 0 ;
7137 PyObject * obj1 = 0 ;
7138 char * kwnames[] = {
7139 (char *) "self",(char *) "rect", NULL
7140 };
7141
7142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7144 if (!SWIG_IsOK(res1)) {
7145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7146 }
7147 arg1 = reinterpret_cast< wxRect * >(argp1);
7148 {
7149 arg2 = &temp2;
7150 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7151 }
7152 {
7153 PyThreadState* __tstate = wxPyBeginAllowThreads();
7154 result = (arg1)->Union((wxRect const &)*arg2);
7155 wxPyEndAllowThreads(__tstate);
7156 if (PyErr_Occurred()) SWIG_fail;
7157 }
7158 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7159 return resultobj;
7160 fail:
7161 return NULL;
7162 }
7163
7164
7165 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7166 PyObject *resultobj = 0;
7167 wxRect *arg1 = (wxRect *) 0 ;
7168 wxRect *arg2 = 0 ;
7169 wxRect result;
7170 void *argp1 = 0 ;
7171 int res1 = 0 ;
7172 wxRect temp2 ;
7173 PyObject * obj0 = 0 ;
7174 PyObject * obj1 = 0 ;
7175 char * kwnames[] = {
7176 (char *) "self",(char *) "rect", NULL
7177 };
7178
7179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7181 if (!SWIG_IsOK(res1)) {
7182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7183 }
7184 arg1 = reinterpret_cast< wxRect * >(argp1);
7185 {
7186 arg2 = &temp2;
7187 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7188 }
7189 {
7190 PyThreadState* __tstate = wxPyBeginAllowThreads();
7191 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7192 wxPyEndAllowThreads(__tstate);
7193 if (PyErr_Occurred()) SWIG_fail;
7194 }
7195 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7196 return resultobj;
7197 fail:
7198 return NULL;
7199 }
7200
7201
7202 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7203 PyObject *resultobj = 0;
7204 wxRect *arg1 = (wxRect *) 0 ;
7205 wxRect *arg2 = 0 ;
7206 wxRect *result = 0 ;
7207 void *argp1 = 0 ;
7208 int res1 = 0 ;
7209 wxRect temp2 ;
7210 PyObject * obj0 = 0 ;
7211 PyObject * obj1 = 0 ;
7212 char * kwnames[] = {
7213 (char *) "self",(char *) "rect", NULL
7214 };
7215
7216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7218 if (!SWIG_IsOK(res1)) {
7219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7220 }
7221 arg1 = reinterpret_cast< wxRect * >(argp1);
7222 {
7223 arg2 = &temp2;
7224 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7225 }
7226 {
7227 PyThreadState* __tstate = wxPyBeginAllowThreads();
7228 {
7229 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7230 result = (wxRect *) &_result_ref;
7231 }
7232 wxPyEndAllowThreads(__tstate);
7233 if (PyErr_Occurred()) SWIG_fail;
7234 }
7235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7236 return resultobj;
7237 fail:
7238 return NULL;
7239 }
7240
7241
7242 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7243 PyObject *resultobj = 0;
7244 wxRect *arg1 = (wxRect *) 0 ;
7245 wxRect *arg2 = 0 ;
7246 bool 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___eq__",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___eq__" "', expected argument " "1"" of type '" "wxRect const *""'");
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 = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
7269 wxPyEndAllowThreads(__tstate);
7270 if (PyErr_Occurred()) SWIG_fail;
7271 }
7272 {
7273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7274 }
7275 return resultobj;
7276 fail:
7277 return NULL;
7278 }
7279
7280
7281 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7282 PyObject *resultobj = 0;
7283 wxRect *arg1 = (wxRect *) 0 ;
7284 wxRect *arg2 = 0 ;
7285 bool result;
7286 void *argp1 = 0 ;
7287 int res1 = 0 ;
7288 wxRect temp2 ;
7289 PyObject * obj0 = 0 ;
7290 PyObject * obj1 = 0 ;
7291 char * kwnames[] = {
7292 (char *) "self",(char *) "rect", NULL
7293 };
7294
7295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7297 if (!SWIG_IsOK(res1)) {
7298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect const *""'");
7299 }
7300 arg1 = reinterpret_cast< wxRect * >(argp1);
7301 {
7302 arg2 = &temp2;
7303 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7304 }
7305 {
7306 PyThreadState* __tstate = wxPyBeginAllowThreads();
7307 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 {
7312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7313 }
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7321 PyObject *resultobj = 0;
7322 wxRect *arg1 = (wxRect *) 0 ;
7323 int arg2 ;
7324 int arg3 ;
7325 bool result;
7326 void *argp1 = 0 ;
7327 int res1 = 0 ;
7328 int val2 ;
7329 int ecode2 = 0 ;
7330 int val3 ;
7331 int ecode3 = 0 ;
7332 PyObject * obj0 = 0 ;
7333 PyObject * obj1 = 0 ;
7334 PyObject * obj2 = 0 ;
7335 char * kwnames[] = {
7336 (char *) "self",(char *) "x",(char *) "y", NULL
7337 };
7338
7339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7341 if (!SWIG_IsOK(res1)) {
7342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7343 }
7344 arg1 = reinterpret_cast< wxRect * >(argp1);
7345 ecode2 = SWIG_AsVal_int(obj1, &val2);
7346 if (!SWIG_IsOK(ecode2)) {
7347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7348 }
7349 arg2 = static_cast< int >(val2);
7350 ecode3 = SWIG_AsVal_int(obj2, &val3);
7351 if (!SWIG_IsOK(ecode3)) {
7352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7353 }
7354 arg3 = static_cast< int >(val3);
7355 {
7356 PyThreadState* __tstate = wxPyBeginAllowThreads();
7357 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7358 wxPyEndAllowThreads(__tstate);
7359 if (PyErr_Occurred()) SWIG_fail;
7360 }
7361 {
7362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7363 }
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7371 PyObject *resultobj = 0;
7372 wxRect *arg1 = (wxRect *) 0 ;
7373 wxPoint *arg2 = 0 ;
7374 bool result;
7375 void *argp1 = 0 ;
7376 int res1 = 0 ;
7377 wxPoint temp2 ;
7378 PyObject * obj0 = 0 ;
7379 PyObject * obj1 = 0 ;
7380 char * kwnames[] = {
7381 (char *) "self",(char *) "pt", NULL
7382 };
7383
7384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7386 if (!SWIG_IsOK(res1)) {
7387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7388 }
7389 arg1 = reinterpret_cast< wxRect * >(argp1);
7390 {
7391 arg2 = &temp2;
7392 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7393 }
7394 {
7395 PyThreadState* __tstate = wxPyBeginAllowThreads();
7396 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7397 wxPyEndAllowThreads(__tstate);
7398 if (PyErr_Occurred()) SWIG_fail;
7399 }
7400 {
7401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7402 }
7403 return resultobj;
7404 fail:
7405 return NULL;
7406 }
7407
7408
7409 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7410 PyObject *resultobj = 0;
7411 wxRect *arg1 = (wxRect *) 0 ;
7412 wxRect *arg2 = 0 ;
7413 bool result;
7414 void *argp1 = 0 ;
7415 int res1 = 0 ;
7416 wxRect temp2 ;
7417 PyObject * obj0 = 0 ;
7418 PyObject * obj1 = 0 ;
7419 char * kwnames[] = {
7420 (char *) "self",(char *) "rect", NULL
7421 };
7422
7423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7425 if (!SWIG_IsOK(res1)) {
7426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7427 }
7428 arg1 = reinterpret_cast< wxRect * >(argp1);
7429 {
7430 arg2 = &temp2;
7431 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7432 }
7433 {
7434 PyThreadState* __tstate = wxPyBeginAllowThreads();
7435 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7436 wxPyEndAllowThreads(__tstate);
7437 if (PyErr_Occurred()) SWIG_fail;
7438 }
7439 {
7440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7441 }
7442 return resultobj;
7443 fail:
7444 return NULL;
7445 }
7446
7447
7448 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7449 PyObject *resultobj = 0;
7450 wxRect *arg1 = (wxRect *) 0 ;
7451 wxRect *arg2 = 0 ;
7452 int arg3 = (int) wxBOTH ;
7453 wxRect result;
7454 void *argp1 = 0 ;
7455 int res1 = 0 ;
7456 wxRect temp2 ;
7457 int val3 ;
7458 int ecode3 = 0 ;
7459 PyObject * obj0 = 0 ;
7460 PyObject * obj1 = 0 ;
7461 PyObject * obj2 = 0 ;
7462 char * kwnames[] = {
7463 (char *) "self",(char *) "r",(char *) "dir", NULL
7464 };
7465
7466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7468 if (!SWIG_IsOK(res1)) {
7469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7470 }
7471 arg1 = reinterpret_cast< wxRect * >(argp1);
7472 {
7473 arg2 = &temp2;
7474 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7475 }
7476 if (obj2) {
7477 ecode3 = SWIG_AsVal_int(obj2, &val3);
7478 if (!SWIG_IsOK(ecode3)) {
7479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7480 }
7481 arg3 = static_cast< int >(val3);
7482 }
7483 {
7484 PyThreadState* __tstate = wxPyBeginAllowThreads();
7485 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7486 wxPyEndAllowThreads(__tstate);
7487 if (PyErr_Occurred()) SWIG_fail;
7488 }
7489 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7490 return resultobj;
7491 fail:
7492 return NULL;
7493 }
7494
7495
7496 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7497 PyObject *resultobj = 0;
7498 wxRect *arg1 = (wxRect *) 0 ;
7499 int arg2 ;
7500 void *argp1 = 0 ;
7501 int res1 = 0 ;
7502 int val2 ;
7503 int ecode2 = 0 ;
7504 PyObject *swig_obj[2] ;
7505
7506 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7508 if (!SWIG_IsOK(res1)) {
7509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7510 }
7511 arg1 = reinterpret_cast< wxRect * >(argp1);
7512 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7513 if (!SWIG_IsOK(ecode2)) {
7514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7515 }
7516 arg2 = static_cast< int >(val2);
7517 if (arg1) (arg1)->x = arg2;
7518
7519 resultobj = SWIG_Py_Void();
7520 return resultobj;
7521 fail:
7522 return NULL;
7523 }
7524
7525
7526 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7527 PyObject *resultobj = 0;
7528 wxRect *arg1 = (wxRect *) 0 ;
7529 int result;
7530 void *argp1 = 0 ;
7531 int res1 = 0 ;
7532 PyObject *swig_obj[1] ;
7533
7534 if (!args) SWIG_fail;
7535 swig_obj[0] = args;
7536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7537 if (!SWIG_IsOK(res1)) {
7538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7539 }
7540 arg1 = reinterpret_cast< wxRect * >(argp1);
7541 result = (int) ((arg1)->x);
7542 resultobj = SWIG_From_int(static_cast< int >(result));
7543 return resultobj;
7544 fail:
7545 return NULL;
7546 }
7547
7548
7549 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7550 PyObject *resultobj = 0;
7551 wxRect *arg1 = (wxRect *) 0 ;
7552 int arg2 ;
7553 void *argp1 = 0 ;
7554 int res1 = 0 ;
7555 int val2 ;
7556 int ecode2 = 0 ;
7557 PyObject *swig_obj[2] ;
7558
7559 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7561 if (!SWIG_IsOK(res1)) {
7562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7563 }
7564 arg1 = reinterpret_cast< wxRect * >(argp1);
7565 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7566 if (!SWIG_IsOK(ecode2)) {
7567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7568 }
7569 arg2 = static_cast< int >(val2);
7570 if (arg1) (arg1)->y = arg2;
7571
7572 resultobj = SWIG_Py_Void();
7573 return resultobj;
7574 fail:
7575 return NULL;
7576 }
7577
7578
7579 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7580 PyObject *resultobj = 0;
7581 wxRect *arg1 = (wxRect *) 0 ;
7582 int result;
7583 void *argp1 = 0 ;
7584 int res1 = 0 ;
7585 PyObject *swig_obj[1] ;
7586
7587 if (!args) SWIG_fail;
7588 swig_obj[0] = args;
7589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7590 if (!SWIG_IsOK(res1)) {
7591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7592 }
7593 arg1 = reinterpret_cast< wxRect * >(argp1);
7594 result = (int) ((arg1)->y);
7595 resultobj = SWIG_From_int(static_cast< int >(result));
7596 return resultobj;
7597 fail:
7598 return NULL;
7599 }
7600
7601
7602 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7603 PyObject *resultobj = 0;
7604 wxRect *arg1 = (wxRect *) 0 ;
7605 int arg2 ;
7606 void *argp1 = 0 ;
7607 int res1 = 0 ;
7608 int val2 ;
7609 int ecode2 = 0 ;
7610 PyObject *swig_obj[2] ;
7611
7612 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7614 if (!SWIG_IsOK(res1)) {
7615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7616 }
7617 arg1 = reinterpret_cast< wxRect * >(argp1);
7618 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7619 if (!SWIG_IsOK(ecode2)) {
7620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7621 }
7622 arg2 = static_cast< int >(val2);
7623 if (arg1) (arg1)->width = arg2;
7624
7625 resultobj = SWIG_Py_Void();
7626 return resultobj;
7627 fail:
7628 return NULL;
7629 }
7630
7631
7632 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7633 PyObject *resultobj = 0;
7634 wxRect *arg1 = (wxRect *) 0 ;
7635 int result;
7636 void *argp1 = 0 ;
7637 int res1 = 0 ;
7638 PyObject *swig_obj[1] ;
7639
7640 if (!args) SWIG_fail;
7641 swig_obj[0] = args;
7642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7643 if (!SWIG_IsOK(res1)) {
7644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7645 }
7646 arg1 = reinterpret_cast< wxRect * >(argp1);
7647 result = (int) ((arg1)->width);
7648 resultobj = SWIG_From_int(static_cast< int >(result));
7649 return resultobj;
7650 fail:
7651 return NULL;
7652 }
7653
7654
7655 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7656 PyObject *resultobj = 0;
7657 wxRect *arg1 = (wxRect *) 0 ;
7658 int arg2 ;
7659 void *argp1 = 0 ;
7660 int res1 = 0 ;
7661 int val2 ;
7662 int ecode2 = 0 ;
7663 PyObject *swig_obj[2] ;
7664
7665 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7667 if (!SWIG_IsOK(res1)) {
7668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7669 }
7670 arg1 = reinterpret_cast< wxRect * >(argp1);
7671 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7672 if (!SWIG_IsOK(ecode2)) {
7673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7674 }
7675 arg2 = static_cast< int >(val2);
7676 if (arg1) (arg1)->height = arg2;
7677
7678 resultobj = SWIG_Py_Void();
7679 return resultobj;
7680 fail:
7681 return NULL;
7682 }
7683
7684
7685 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7686 PyObject *resultobj = 0;
7687 wxRect *arg1 = (wxRect *) 0 ;
7688 int result;
7689 void *argp1 = 0 ;
7690 int res1 = 0 ;
7691 PyObject *swig_obj[1] ;
7692
7693 if (!args) SWIG_fail;
7694 swig_obj[0] = args;
7695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7696 if (!SWIG_IsOK(res1)) {
7697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7698 }
7699 arg1 = reinterpret_cast< wxRect * >(argp1);
7700 result = (int) ((arg1)->height);
7701 resultobj = SWIG_From_int(static_cast< int >(result));
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7709 PyObject *resultobj = 0;
7710 wxRect *arg1 = (wxRect *) 0 ;
7711 int arg2 = (int) 0 ;
7712 int arg3 = (int) 0 ;
7713 int arg4 = (int) 0 ;
7714 int arg5 = (int) 0 ;
7715 void *argp1 = 0 ;
7716 int res1 = 0 ;
7717 int val2 ;
7718 int ecode2 = 0 ;
7719 int val3 ;
7720 int ecode3 = 0 ;
7721 int val4 ;
7722 int ecode4 = 0 ;
7723 int val5 ;
7724 int ecode5 = 0 ;
7725 PyObject * obj0 = 0 ;
7726 PyObject * obj1 = 0 ;
7727 PyObject * obj2 = 0 ;
7728 PyObject * obj3 = 0 ;
7729 PyObject * obj4 = 0 ;
7730 char * kwnames[] = {
7731 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7732 };
7733
7734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7736 if (!SWIG_IsOK(res1)) {
7737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7738 }
7739 arg1 = reinterpret_cast< wxRect * >(argp1);
7740 if (obj1) {
7741 ecode2 = SWIG_AsVal_int(obj1, &val2);
7742 if (!SWIG_IsOK(ecode2)) {
7743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7744 }
7745 arg2 = static_cast< int >(val2);
7746 }
7747 if (obj2) {
7748 ecode3 = SWIG_AsVal_int(obj2, &val3);
7749 if (!SWIG_IsOK(ecode3)) {
7750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7751 }
7752 arg3 = static_cast< int >(val3);
7753 }
7754 if (obj3) {
7755 ecode4 = SWIG_AsVal_int(obj3, &val4);
7756 if (!SWIG_IsOK(ecode4)) {
7757 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7758 }
7759 arg4 = static_cast< int >(val4);
7760 }
7761 if (obj4) {
7762 ecode5 = SWIG_AsVal_int(obj4, &val5);
7763 if (!SWIG_IsOK(ecode5)) {
7764 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7765 }
7766 arg5 = static_cast< int >(val5);
7767 }
7768 {
7769 PyThreadState* __tstate = wxPyBeginAllowThreads();
7770 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7771 wxPyEndAllowThreads(__tstate);
7772 if (PyErr_Occurred()) SWIG_fail;
7773 }
7774 resultobj = SWIG_Py_Void();
7775 return resultobj;
7776 fail:
7777 return NULL;
7778 }
7779
7780
7781 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7782 PyObject *resultobj = 0;
7783 wxRect *arg1 = (wxRect *) 0 ;
7784 PyObject *result = 0 ;
7785 void *argp1 = 0 ;
7786 int res1 = 0 ;
7787 PyObject *swig_obj[1] ;
7788
7789 if (!args) SWIG_fail;
7790 swig_obj[0] = args;
7791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7792 if (!SWIG_IsOK(res1)) {
7793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7794 }
7795 arg1 = reinterpret_cast< wxRect * >(argp1);
7796 {
7797 PyThreadState* __tstate = wxPyBeginAllowThreads();
7798 result = (PyObject *)wxRect_Get(arg1);
7799 wxPyEndAllowThreads(__tstate);
7800 if (PyErr_Occurred()) SWIG_fail;
7801 }
7802 resultobj = result;
7803 return resultobj;
7804 fail:
7805 return NULL;
7806 }
7807
7808
7809 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7810 PyObject *obj;
7811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7812 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7813 return SWIG_Py_Void();
7814 }
7815
7816 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7817 return SWIG_Python_InitShadowInstance(args);
7818 }
7819
7820 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7821 PyObject *resultobj = 0;
7822 wxRect *arg1 = (wxRect *) 0 ;
7823 wxRect *arg2 = (wxRect *) 0 ;
7824 PyObject *result = 0 ;
7825 void *argp1 = 0 ;
7826 int res1 = 0 ;
7827 void *argp2 = 0 ;
7828 int res2 = 0 ;
7829 PyObject * obj0 = 0 ;
7830 PyObject * obj1 = 0 ;
7831 char * kwnames[] = {
7832 (char *) "r1",(char *) "r2", NULL
7833 };
7834
7835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7837 if (!SWIG_IsOK(res1)) {
7838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7839 }
7840 arg1 = reinterpret_cast< wxRect * >(argp1);
7841 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7842 if (!SWIG_IsOK(res2)) {
7843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7844 }
7845 arg2 = reinterpret_cast< wxRect * >(argp2);
7846 {
7847 if (!wxPyCheckForApp()) SWIG_fail;
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 result = (PyObject *)wxIntersectRect(arg1,arg2);
7850 wxPyEndAllowThreads(__tstate);
7851 if (PyErr_Occurred()) SWIG_fail;
7852 }
7853 resultobj = result;
7854 return resultobj;
7855 fail:
7856 return NULL;
7857 }
7858
7859
7860 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7861 PyObject *resultobj = 0;
7862 double arg1 = (double) 0.0 ;
7863 double arg2 = (double) 0.0 ;
7864 wxPoint2D *result = 0 ;
7865 double val1 ;
7866 int ecode1 = 0 ;
7867 double val2 ;
7868 int ecode2 = 0 ;
7869 PyObject * obj0 = 0 ;
7870 PyObject * obj1 = 0 ;
7871 char * kwnames[] = {
7872 (char *) "x",(char *) "y", NULL
7873 };
7874
7875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7876 if (obj0) {
7877 ecode1 = SWIG_AsVal_double(obj0, &val1);
7878 if (!SWIG_IsOK(ecode1)) {
7879 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7880 }
7881 arg1 = static_cast< double >(val1);
7882 }
7883 if (obj1) {
7884 ecode2 = SWIG_AsVal_double(obj1, &val2);
7885 if (!SWIG_IsOK(ecode2)) {
7886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7887 }
7888 arg2 = static_cast< double >(val2);
7889 }
7890 {
7891 PyThreadState* __tstate = wxPyBeginAllowThreads();
7892 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7893 wxPyEndAllowThreads(__tstate);
7894 if (PyErr_Occurred()) SWIG_fail;
7895 }
7896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7897 return resultobj;
7898 fail:
7899 return NULL;
7900 }
7901
7902
7903 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7904 PyObject *resultobj = 0;
7905 wxPoint2D *arg1 = 0 ;
7906 wxPoint2D *result = 0 ;
7907 wxPoint2D temp1 ;
7908 PyObject * obj0 = 0 ;
7909 char * kwnames[] = {
7910 (char *) "pt", NULL
7911 };
7912
7913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
7914 {
7915 arg1 = &temp1;
7916 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
7917 }
7918 {
7919 PyThreadState* __tstate = wxPyBeginAllowThreads();
7920 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
7921 wxPyEndAllowThreads(__tstate);
7922 if (PyErr_Occurred()) SWIG_fail;
7923 }
7924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
7925 return resultobj;
7926 fail:
7927 return NULL;
7928 }
7929
7930
7931 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7932 PyObject *resultobj = 0;
7933 wxPoint *arg1 = 0 ;
7934 wxPoint2D *result = 0 ;
7935 wxPoint temp1 ;
7936 PyObject * obj0 = 0 ;
7937 char * kwnames[] = {
7938 (char *) "pt", NULL
7939 };
7940
7941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
7942 {
7943 arg1 = &temp1;
7944 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7945 }
7946 {
7947 PyThreadState* __tstate = wxPyBeginAllowThreads();
7948 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
7949 wxPyEndAllowThreads(__tstate);
7950 if (PyErr_Occurred()) SWIG_fail;
7951 }
7952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
7953 return resultobj;
7954 fail:
7955 return NULL;
7956 }
7957
7958
7959 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7960 PyObject *resultobj = 0;
7961 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7962 int *arg2 = (int *) 0 ;
7963 int *arg3 = (int *) 0 ;
7964 void *argp1 = 0 ;
7965 int res1 = 0 ;
7966 int temp2 ;
7967 int res2 = SWIG_TMPOBJ ;
7968 int temp3 ;
7969 int res3 = SWIG_TMPOBJ ;
7970 PyObject *swig_obj[1] ;
7971
7972 arg2 = &temp2;
7973 arg3 = &temp3;
7974 if (!args) SWIG_fail;
7975 swig_obj[0] = args;
7976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
7977 if (!SWIG_IsOK(res1)) {
7978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
7979 }
7980 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
7981 {
7982 PyThreadState* __tstate = wxPyBeginAllowThreads();
7983 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
7984 wxPyEndAllowThreads(__tstate);
7985 if (PyErr_Occurred()) SWIG_fail;
7986 }
7987 resultobj = SWIG_Py_Void();
7988 if (SWIG_IsTmpObj(res2)) {
7989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7990 } else {
7991 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7993 }
7994 if (SWIG_IsTmpObj(res3)) {
7995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7996 } else {
7997 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7999 }
8000 return resultobj;
8001 fail:
8002 return NULL;
8003 }
8004
8005
8006 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8007 PyObject *resultobj = 0;
8008 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8009 int *arg2 = (int *) 0 ;
8010 int *arg3 = (int *) 0 ;
8011 void *argp1 = 0 ;
8012 int res1 = 0 ;
8013 int temp2 ;
8014 int res2 = SWIG_TMPOBJ ;
8015 int temp3 ;
8016 int res3 = SWIG_TMPOBJ ;
8017 PyObject *swig_obj[1] ;
8018
8019 arg2 = &temp2;
8020 arg3 = &temp3;
8021 if (!args) SWIG_fail;
8022 swig_obj[0] = args;
8023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8024 if (!SWIG_IsOK(res1)) {
8025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8026 }
8027 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8028 {
8029 PyThreadState* __tstate = wxPyBeginAllowThreads();
8030 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8031 wxPyEndAllowThreads(__tstate);
8032 if (PyErr_Occurred()) SWIG_fail;
8033 }
8034 resultobj = SWIG_Py_Void();
8035 if (SWIG_IsTmpObj(res2)) {
8036 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8037 } else {
8038 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8039 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8040 }
8041 if (SWIG_IsTmpObj(res3)) {
8042 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8043 } else {
8044 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8046 }
8047 return resultobj;
8048 fail:
8049 return NULL;
8050 }
8051
8052
8053 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8054 PyObject *resultobj = 0;
8055 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8056 double result;
8057 void *argp1 = 0 ;
8058 int res1 = 0 ;
8059 PyObject *swig_obj[1] ;
8060
8061 if (!args) SWIG_fail;
8062 swig_obj[0] = args;
8063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8064 if (!SWIG_IsOK(res1)) {
8065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8066 }
8067 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8068 {
8069 PyThreadState* __tstate = wxPyBeginAllowThreads();
8070 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8071 wxPyEndAllowThreads(__tstate);
8072 if (PyErr_Occurred()) SWIG_fail;
8073 }
8074 resultobj = SWIG_From_double(static_cast< double >(result));
8075 return resultobj;
8076 fail:
8077 return NULL;
8078 }
8079
8080
8081 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8082 PyObject *resultobj = 0;
8083 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8084 double result;
8085 void *argp1 = 0 ;
8086 int res1 = 0 ;
8087 PyObject *swig_obj[1] ;
8088
8089 if (!args) SWIG_fail;
8090 swig_obj[0] = args;
8091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8092 if (!SWIG_IsOK(res1)) {
8093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8094 }
8095 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8096 {
8097 PyThreadState* __tstate = wxPyBeginAllowThreads();
8098 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8099 wxPyEndAllowThreads(__tstate);
8100 if (PyErr_Occurred()) SWIG_fail;
8101 }
8102 resultobj = SWIG_From_double(static_cast< double >(result));
8103 return resultobj;
8104 fail:
8105 return NULL;
8106 }
8107
8108
8109 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8110 PyObject *resultobj = 0;
8111 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8112 double arg2 ;
8113 void *argp1 = 0 ;
8114 int res1 = 0 ;
8115 double val2 ;
8116 int ecode2 = 0 ;
8117 PyObject * obj0 = 0 ;
8118 PyObject * obj1 = 0 ;
8119 char * kwnames[] = {
8120 (char *) "self",(char *) "length", NULL
8121 };
8122
8123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8125 if (!SWIG_IsOK(res1)) {
8126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8127 }
8128 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8129 ecode2 = SWIG_AsVal_double(obj1, &val2);
8130 if (!SWIG_IsOK(ecode2)) {
8131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8132 }
8133 arg2 = static_cast< double >(val2);
8134 {
8135 PyThreadState* __tstate = wxPyBeginAllowThreads();
8136 (arg1)->SetVectorLength(arg2);
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 resultobj = SWIG_Py_Void();
8141 return resultobj;
8142 fail:
8143 return NULL;
8144 }
8145
8146
8147 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8148 PyObject *resultobj = 0;
8149 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8150 double arg2 ;
8151 void *argp1 = 0 ;
8152 int res1 = 0 ;
8153 double val2 ;
8154 int ecode2 = 0 ;
8155 PyObject * obj0 = 0 ;
8156 PyObject * obj1 = 0 ;
8157 char * kwnames[] = {
8158 (char *) "self",(char *) "degrees", NULL
8159 };
8160
8161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8163 if (!SWIG_IsOK(res1)) {
8164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8165 }
8166 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8167 ecode2 = SWIG_AsVal_double(obj1, &val2);
8168 if (!SWIG_IsOK(ecode2)) {
8169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8170 }
8171 arg2 = static_cast< double >(val2);
8172 {
8173 PyThreadState* __tstate = wxPyBeginAllowThreads();
8174 (arg1)->SetVectorAngle(arg2);
8175 wxPyEndAllowThreads(__tstate);
8176 if (PyErr_Occurred()) SWIG_fail;
8177 }
8178 resultobj = SWIG_Py_Void();
8179 return resultobj;
8180 fail:
8181 return NULL;
8182 }
8183
8184
8185 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8186 PyObject *resultobj = 0;
8187 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8188 wxPoint2D *arg2 = 0 ;
8189 double result;
8190 void *argp1 = 0 ;
8191 int res1 = 0 ;
8192 wxPoint2D temp2 ;
8193 PyObject * obj0 = 0 ;
8194 PyObject * obj1 = 0 ;
8195 char * kwnames[] = {
8196 (char *) "self",(char *) "pt", NULL
8197 };
8198
8199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8201 if (!SWIG_IsOK(res1)) {
8202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8203 }
8204 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8205 {
8206 arg2 = &temp2;
8207 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8208 }
8209 {
8210 PyThreadState* __tstate = wxPyBeginAllowThreads();
8211 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8212 wxPyEndAllowThreads(__tstate);
8213 if (PyErr_Occurred()) SWIG_fail;
8214 }
8215 resultobj = SWIG_From_double(static_cast< double >(result));
8216 return resultobj;
8217 fail:
8218 return NULL;
8219 }
8220
8221
8222 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8223 PyObject *resultobj = 0;
8224 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8225 wxPoint2D *arg2 = 0 ;
8226 double result;
8227 void *argp1 = 0 ;
8228 int res1 = 0 ;
8229 wxPoint2D temp2 ;
8230 PyObject * obj0 = 0 ;
8231 PyObject * obj1 = 0 ;
8232 char * kwnames[] = {
8233 (char *) "self",(char *) "pt", NULL
8234 };
8235
8236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8238 if (!SWIG_IsOK(res1)) {
8239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8240 }
8241 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8242 {
8243 arg2 = &temp2;
8244 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8245 }
8246 {
8247 PyThreadState* __tstate = wxPyBeginAllowThreads();
8248 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8249 wxPyEndAllowThreads(__tstate);
8250 if (PyErr_Occurred()) SWIG_fail;
8251 }
8252 resultobj = SWIG_From_double(static_cast< double >(result));
8253 return resultobj;
8254 fail:
8255 return NULL;
8256 }
8257
8258
8259 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8260 PyObject *resultobj = 0;
8261 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8262 wxPoint2D *arg2 = 0 ;
8263 double result;
8264 void *argp1 = 0 ;
8265 int res1 = 0 ;
8266 wxPoint2D temp2 ;
8267 PyObject * obj0 = 0 ;
8268 PyObject * obj1 = 0 ;
8269 char * kwnames[] = {
8270 (char *) "self",(char *) "vec", NULL
8271 };
8272
8273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8275 if (!SWIG_IsOK(res1)) {
8276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8277 }
8278 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8279 {
8280 arg2 = &temp2;
8281 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8282 }
8283 {
8284 PyThreadState* __tstate = wxPyBeginAllowThreads();
8285 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8286 wxPyEndAllowThreads(__tstate);
8287 if (PyErr_Occurred()) SWIG_fail;
8288 }
8289 resultobj = SWIG_From_double(static_cast< double >(result));
8290 return resultobj;
8291 fail:
8292 return NULL;
8293 }
8294
8295
8296 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8297 PyObject *resultobj = 0;
8298 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8299 wxPoint2D *arg2 = 0 ;
8300 double result;
8301 void *argp1 = 0 ;
8302 int res1 = 0 ;
8303 wxPoint2D temp2 ;
8304 PyObject * obj0 = 0 ;
8305 PyObject * obj1 = 0 ;
8306 char * kwnames[] = {
8307 (char *) "self",(char *) "vec", NULL
8308 };
8309
8310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8312 if (!SWIG_IsOK(res1)) {
8313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8314 }
8315 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8316 {
8317 arg2 = &temp2;
8318 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8319 }
8320 {
8321 PyThreadState* __tstate = wxPyBeginAllowThreads();
8322 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8323 wxPyEndAllowThreads(__tstate);
8324 if (PyErr_Occurred()) SWIG_fail;
8325 }
8326 resultobj = SWIG_From_double(static_cast< double >(result));
8327 return resultobj;
8328 fail:
8329 return NULL;
8330 }
8331
8332
8333 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8334 PyObject *resultobj = 0;
8335 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8336 wxPoint2D result;
8337 void *argp1 = 0 ;
8338 int res1 = 0 ;
8339 PyObject *swig_obj[1] ;
8340
8341 if (!args) SWIG_fail;
8342 swig_obj[0] = args;
8343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8344 if (!SWIG_IsOK(res1)) {
8345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8346 }
8347 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8348 {
8349 PyThreadState* __tstate = wxPyBeginAllowThreads();
8350 result = (arg1)->operator -();
8351 wxPyEndAllowThreads(__tstate);
8352 if (PyErr_Occurred()) SWIG_fail;
8353 }
8354 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8355 return resultobj;
8356 fail:
8357 return NULL;
8358 }
8359
8360
8361 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8362 PyObject *resultobj = 0;
8363 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8364 wxPoint2D *arg2 = 0 ;
8365 wxPoint2D *result = 0 ;
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 *) "pt", NULL
8373 };
8374
8375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8377 if (!SWIG_IsOK(res1)) {
8378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
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 {
8388 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8389 result = (wxPoint2D *) &_result_ref;
8390 }
8391 wxPyEndAllowThreads(__tstate);
8392 if (PyErr_Occurred()) SWIG_fail;
8393 }
8394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8395 return resultobj;
8396 fail:
8397 return NULL;
8398 }
8399
8400
8401 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8402 PyObject *resultobj = 0;
8403 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8404 wxPoint2D *arg2 = 0 ;
8405 wxPoint2D *result = 0 ;
8406 void *argp1 = 0 ;
8407 int res1 = 0 ;
8408 wxPoint2D temp2 ;
8409 PyObject * obj0 = 0 ;
8410 PyObject * obj1 = 0 ;
8411 char * kwnames[] = {
8412 (char *) "self",(char *) "pt", NULL
8413 };
8414
8415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8417 if (!SWIG_IsOK(res1)) {
8418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8419 }
8420 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8421 {
8422 arg2 = &temp2;
8423 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8424 }
8425 {
8426 PyThreadState* __tstate = wxPyBeginAllowThreads();
8427 {
8428 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8429 result = (wxPoint2D *) &_result_ref;
8430 }
8431 wxPyEndAllowThreads(__tstate);
8432 if (PyErr_Occurred()) SWIG_fail;
8433 }
8434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8435 return resultobj;
8436 fail:
8437 return NULL;
8438 }
8439
8440
8441 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8442 PyObject *resultobj = 0;
8443 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8444 wxPoint2D *arg2 = 0 ;
8445 wxPoint2D *result = 0 ;
8446 void *argp1 = 0 ;
8447 int res1 = 0 ;
8448 wxPoint2D temp2 ;
8449 PyObject * obj0 = 0 ;
8450 PyObject * obj1 = 0 ;
8451 char * kwnames[] = {
8452 (char *) "self",(char *) "pt", NULL
8453 };
8454
8455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8457 if (!SWIG_IsOK(res1)) {
8458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8459 }
8460 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8461 {
8462 arg2 = &temp2;
8463 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8464 }
8465 {
8466 PyThreadState* __tstate = wxPyBeginAllowThreads();
8467 {
8468 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8469 result = (wxPoint2D *) &_result_ref;
8470 }
8471 wxPyEndAllowThreads(__tstate);
8472 if (PyErr_Occurred()) SWIG_fail;
8473 }
8474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8475 return resultobj;
8476 fail:
8477 return NULL;
8478 }
8479
8480
8481 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8482 PyObject *resultobj = 0;
8483 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8484 wxPoint2D *arg2 = 0 ;
8485 wxPoint2D *result = 0 ;
8486 void *argp1 = 0 ;
8487 int res1 = 0 ;
8488 wxPoint2D temp2 ;
8489 PyObject * obj0 = 0 ;
8490 PyObject * obj1 = 0 ;
8491 char * kwnames[] = {
8492 (char *) "self",(char *) "pt", NULL
8493 };
8494
8495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8497 if (!SWIG_IsOK(res1)) {
8498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8499 }
8500 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8501 {
8502 arg2 = &temp2;
8503 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8504 }
8505 {
8506 PyThreadState* __tstate = wxPyBeginAllowThreads();
8507 {
8508 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8509 result = (wxPoint2D *) &_result_ref;
8510 }
8511 wxPyEndAllowThreads(__tstate);
8512 if (PyErr_Occurred()) SWIG_fail;
8513 }
8514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8515 return resultobj;
8516 fail:
8517 return NULL;
8518 }
8519
8520
8521 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8522 PyObject *resultobj = 0;
8523 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8524 wxPoint2D *arg2 = 0 ;
8525 bool result;
8526 void *argp1 = 0 ;
8527 int res1 = 0 ;
8528 wxPoint2D temp2 ;
8529 PyObject * obj0 = 0 ;
8530 PyObject * obj1 = 0 ;
8531 char * kwnames[] = {
8532 (char *) "self",(char *) "pt", NULL
8533 };
8534
8535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8537 if (!SWIG_IsOK(res1)) {
8538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8539 }
8540 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8541 {
8542 arg2 = &temp2;
8543 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8544 }
8545 {
8546 PyThreadState* __tstate = wxPyBeginAllowThreads();
8547 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
8548 wxPyEndAllowThreads(__tstate);
8549 if (PyErr_Occurred()) SWIG_fail;
8550 }
8551 {
8552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8553 }
8554 return resultobj;
8555 fail:
8556 return NULL;
8557 }
8558
8559
8560 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8561 PyObject *resultobj = 0;
8562 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8563 wxPoint2D *arg2 = 0 ;
8564 bool result;
8565 void *argp1 = 0 ;
8566 int res1 = 0 ;
8567 wxPoint2D temp2 ;
8568 PyObject * obj0 = 0 ;
8569 PyObject * obj1 = 0 ;
8570 char * kwnames[] = {
8571 (char *) "self",(char *) "pt", NULL
8572 };
8573
8574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8576 if (!SWIG_IsOK(res1)) {
8577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8578 }
8579 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8580 {
8581 arg2 = &temp2;
8582 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8583 }
8584 {
8585 PyThreadState* __tstate = wxPyBeginAllowThreads();
8586 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
8587 wxPyEndAllowThreads(__tstate);
8588 if (PyErr_Occurred()) SWIG_fail;
8589 }
8590 {
8591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8592 }
8593 return resultobj;
8594 fail:
8595 return NULL;
8596 }
8597
8598
8599 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8600 PyObject *resultobj = 0;
8601 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8602 double arg2 ;
8603 void *argp1 = 0 ;
8604 int res1 = 0 ;
8605 double val2 ;
8606 int ecode2 = 0 ;
8607 PyObject *swig_obj[2] ;
8608
8609 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8611 if (!SWIG_IsOK(res1)) {
8612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8613 }
8614 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8615 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8616 if (!SWIG_IsOK(ecode2)) {
8617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8618 }
8619 arg2 = static_cast< double >(val2);
8620 if (arg1) (arg1)->m_x = arg2;
8621
8622 resultobj = SWIG_Py_Void();
8623 return resultobj;
8624 fail:
8625 return NULL;
8626 }
8627
8628
8629 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8630 PyObject *resultobj = 0;
8631 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8632 double result;
8633 void *argp1 = 0 ;
8634 int res1 = 0 ;
8635 PyObject *swig_obj[1] ;
8636
8637 if (!args) SWIG_fail;
8638 swig_obj[0] = args;
8639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8640 if (!SWIG_IsOK(res1)) {
8641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8642 }
8643 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8644 result = (double) ((arg1)->m_x);
8645 resultobj = SWIG_From_double(static_cast< double >(result));
8646 return resultobj;
8647 fail:
8648 return NULL;
8649 }
8650
8651
8652 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8653 PyObject *resultobj = 0;
8654 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8655 double arg2 ;
8656 void *argp1 = 0 ;
8657 int res1 = 0 ;
8658 double val2 ;
8659 int ecode2 = 0 ;
8660 PyObject *swig_obj[2] ;
8661
8662 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8664 if (!SWIG_IsOK(res1)) {
8665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8666 }
8667 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8668 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8669 if (!SWIG_IsOK(ecode2)) {
8670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8671 }
8672 arg2 = static_cast< double >(val2);
8673 if (arg1) (arg1)->m_y = arg2;
8674
8675 resultobj = SWIG_Py_Void();
8676 return resultobj;
8677 fail:
8678 return NULL;
8679 }
8680
8681
8682 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8683 PyObject *resultobj = 0;
8684 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8685 double result;
8686 void *argp1 = 0 ;
8687 int res1 = 0 ;
8688 PyObject *swig_obj[1] ;
8689
8690 if (!args) SWIG_fail;
8691 swig_obj[0] = args;
8692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8693 if (!SWIG_IsOK(res1)) {
8694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8695 }
8696 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8697 result = (double) ((arg1)->m_y);
8698 resultobj = SWIG_From_double(static_cast< double >(result));
8699 return resultobj;
8700 fail:
8701 return NULL;
8702 }
8703
8704
8705 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8706 PyObject *resultobj = 0;
8707 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8708 double arg2 = (double) 0 ;
8709 double arg3 = (double) 0 ;
8710 void *argp1 = 0 ;
8711 int res1 = 0 ;
8712 double val2 ;
8713 int ecode2 = 0 ;
8714 double val3 ;
8715 int ecode3 = 0 ;
8716 PyObject * obj0 = 0 ;
8717 PyObject * obj1 = 0 ;
8718 PyObject * obj2 = 0 ;
8719 char * kwnames[] = {
8720 (char *) "self",(char *) "x",(char *) "y", NULL
8721 };
8722
8723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8725 if (!SWIG_IsOK(res1)) {
8726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8727 }
8728 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8729 if (obj1) {
8730 ecode2 = SWIG_AsVal_double(obj1, &val2);
8731 if (!SWIG_IsOK(ecode2)) {
8732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8733 }
8734 arg2 = static_cast< double >(val2);
8735 }
8736 if (obj2) {
8737 ecode3 = SWIG_AsVal_double(obj2, &val3);
8738 if (!SWIG_IsOK(ecode3)) {
8739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8740 }
8741 arg3 = static_cast< double >(val3);
8742 }
8743 {
8744 PyThreadState* __tstate = wxPyBeginAllowThreads();
8745 wxPoint2D_Set(arg1,arg2,arg3);
8746 wxPyEndAllowThreads(__tstate);
8747 if (PyErr_Occurred()) SWIG_fail;
8748 }
8749 resultobj = SWIG_Py_Void();
8750 return resultobj;
8751 fail:
8752 return NULL;
8753 }
8754
8755
8756 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8757 PyObject *resultobj = 0;
8758 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8759 PyObject *result = 0 ;
8760 void *argp1 = 0 ;
8761 int res1 = 0 ;
8762 PyObject *swig_obj[1] ;
8763
8764 if (!args) SWIG_fail;
8765 swig_obj[0] = args;
8766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8767 if (!SWIG_IsOK(res1)) {
8768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8769 }
8770 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8771 {
8772 PyThreadState* __tstate = wxPyBeginAllowThreads();
8773 result = (PyObject *)wxPoint2D_Get(arg1);
8774 wxPyEndAllowThreads(__tstate);
8775 if (PyErr_Occurred()) SWIG_fail;
8776 }
8777 resultobj = result;
8778 return resultobj;
8779 fail:
8780 return NULL;
8781 }
8782
8783
8784 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8785 PyObject *obj;
8786 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8787 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8788 return SWIG_Py_Void();
8789 }
8790
8791 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8792 return SWIG_Python_InitShadowInstance(args);
8793 }
8794
8795 SWIGINTERN int DefaultPosition_set(PyObject *) {
8796 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8797 return 1;
8798 }
8799
8800
8801 SWIGINTERN PyObject *DefaultPosition_get(void) {
8802 PyObject *pyobj = 0;
8803
8804 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8805 return pyobj;
8806 }
8807
8808
8809 SWIGINTERN int DefaultSize_set(PyObject *) {
8810 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8811 return 1;
8812 }
8813
8814
8815 SWIGINTERN PyObject *DefaultSize_get(void) {
8816 PyObject *pyobj = 0;
8817
8818 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8819 return pyobj;
8820 }
8821
8822
8823 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8824 PyObject *resultobj = 0;
8825 PyObject *arg1 = (PyObject *) 0 ;
8826 wxPyInputStream *result = 0 ;
8827 PyObject * obj0 = 0 ;
8828 char * kwnames[] = {
8829 (char *) "p", NULL
8830 };
8831
8832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8833 arg1 = obj0;
8834 {
8835 PyThreadState* __tstate = wxPyBeginAllowThreads();
8836 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8837 wxPyEndAllowThreads(__tstate);
8838 if (PyErr_Occurred()) SWIG_fail;
8839 }
8840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8841 return resultobj;
8842 fail:
8843 return NULL;
8844 }
8845
8846
8847 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8848 PyObject *resultobj = 0;
8849 wxPyInputStream *arg1 = (wxPyInputStream *) 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_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8857 if (!SWIG_IsOK(res1)) {
8858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8859 }
8860 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8861 {
8862 PyThreadState* __tstate = wxPyBeginAllowThreads();
8863 delete arg1;
8864
8865 wxPyEndAllowThreads(__tstate);
8866 if (PyErr_Occurred()) SWIG_fail;
8867 }
8868 resultobj = SWIG_Py_Void();
8869 return resultobj;
8870 fail:
8871 return NULL;
8872 }
8873
8874
8875 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8876 PyObject *resultobj = 0;
8877 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8878 void *argp1 = 0 ;
8879 int res1 = 0 ;
8880 PyObject *swig_obj[1] ;
8881
8882 if (!args) SWIG_fail;
8883 swig_obj[0] = args;
8884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8885 if (!SWIG_IsOK(res1)) {
8886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8887 }
8888 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8889 {
8890 PyThreadState* __tstate = wxPyBeginAllowThreads();
8891 (arg1)->close();
8892 wxPyEndAllowThreads(__tstate);
8893 if (PyErr_Occurred()) SWIG_fail;
8894 }
8895 resultobj = SWIG_Py_Void();
8896 return resultobj;
8897 fail:
8898 return NULL;
8899 }
8900
8901
8902 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8903 PyObject *resultobj = 0;
8904 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8905 void *argp1 = 0 ;
8906 int res1 = 0 ;
8907 PyObject *swig_obj[1] ;
8908
8909 if (!args) SWIG_fail;
8910 swig_obj[0] = args;
8911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8912 if (!SWIG_IsOK(res1)) {
8913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8914 }
8915 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8916 {
8917 PyThreadState* __tstate = wxPyBeginAllowThreads();
8918 (arg1)->flush();
8919 wxPyEndAllowThreads(__tstate);
8920 if (PyErr_Occurred()) SWIG_fail;
8921 }
8922 resultobj = SWIG_Py_Void();
8923 return resultobj;
8924 fail:
8925 return NULL;
8926 }
8927
8928
8929 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8930 PyObject *resultobj = 0;
8931 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8932 bool result;
8933 void *argp1 = 0 ;
8934 int res1 = 0 ;
8935 PyObject *swig_obj[1] ;
8936
8937 if (!args) SWIG_fail;
8938 swig_obj[0] = args;
8939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8940 if (!SWIG_IsOK(res1)) {
8941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8942 }
8943 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8944 {
8945 PyThreadState* __tstate = wxPyBeginAllowThreads();
8946 result = (bool)(arg1)->eof();
8947 wxPyEndAllowThreads(__tstate);
8948 if (PyErr_Occurred()) SWIG_fail;
8949 }
8950 {
8951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8952 }
8953 return resultobj;
8954 fail:
8955 return NULL;
8956 }
8957
8958
8959 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8960 PyObject *resultobj = 0;
8961 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8962 int arg2 = (int) -1 ;
8963 PyObject *result = 0 ;
8964 void *argp1 = 0 ;
8965 int res1 = 0 ;
8966 int val2 ;
8967 int ecode2 = 0 ;
8968 PyObject * obj0 = 0 ;
8969 PyObject * obj1 = 0 ;
8970 char * kwnames[] = {
8971 (char *) "self",(char *) "size", NULL
8972 };
8973
8974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
8975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8976 if (!SWIG_IsOK(res1)) {
8977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8978 }
8979 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8980 if (obj1) {
8981 ecode2 = SWIG_AsVal_int(obj1, &val2);
8982 if (!SWIG_IsOK(ecode2)) {
8983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
8984 }
8985 arg2 = static_cast< int >(val2);
8986 }
8987 {
8988 PyThreadState* __tstate = wxPyBeginAllowThreads();
8989 result = (PyObject *)(arg1)->read(arg2);
8990 wxPyEndAllowThreads(__tstate);
8991 if (PyErr_Occurred()) SWIG_fail;
8992 }
8993 resultobj = result;
8994 return resultobj;
8995 fail:
8996 return NULL;
8997 }
8998
8999
9000 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9001 PyObject *resultobj = 0;
9002 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9003 int arg2 = (int) -1 ;
9004 PyObject *result = 0 ;
9005 void *argp1 = 0 ;
9006 int res1 = 0 ;
9007 int val2 ;
9008 int ecode2 = 0 ;
9009 PyObject * obj0 = 0 ;
9010 PyObject * obj1 = 0 ;
9011 char * kwnames[] = {
9012 (char *) "self",(char *) "size", NULL
9013 };
9014
9015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9017 if (!SWIG_IsOK(res1)) {
9018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9019 }
9020 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9021 if (obj1) {
9022 ecode2 = SWIG_AsVal_int(obj1, &val2);
9023 if (!SWIG_IsOK(ecode2)) {
9024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9025 }
9026 arg2 = static_cast< int >(val2);
9027 }
9028 {
9029 PyThreadState* __tstate = wxPyBeginAllowThreads();
9030 result = (PyObject *)(arg1)->readline(arg2);
9031 wxPyEndAllowThreads(__tstate);
9032 if (PyErr_Occurred()) SWIG_fail;
9033 }
9034 resultobj = result;
9035 return resultobj;
9036 fail:
9037 return NULL;
9038 }
9039
9040
9041 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9042 PyObject *resultobj = 0;
9043 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9044 int arg2 = (int) -1 ;
9045 PyObject *result = 0 ;
9046 void *argp1 = 0 ;
9047 int res1 = 0 ;
9048 int val2 ;
9049 int ecode2 = 0 ;
9050 PyObject * obj0 = 0 ;
9051 PyObject * obj1 = 0 ;
9052 char * kwnames[] = {
9053 (char *) "self",(char *) "sizehint", NULL
9054 };
9055
9056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9058 if (!SWIG_IsOK(res1)) {
9059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9060 }
9061 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9062 if (obj1) {
9063 ecode2 = SWIG_AsVal_int(obj1, &val2);
9064 if (!SWIG_IsOK(ecode2)) {
9065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9066 }
9067 arg2 = static_cast< int >(val2);
9068 }
9069 {
9070 PyThreadState* __tstate = wxPyBeginAllowThreads();
9071 result = (PyObject *)(arg1)->readlines(arg2);
9072 wxPyEndAllowThreads(__tstate);
9073 if (PyErr_Occurred()) SWIG_fail;
9074 }
9075 resultobj = result;
9076 return resultobj;
9077 fail:
9078 return NULL;
9079 }
9080
9081
9082 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9083 PyObject *resultobj = 0;
9084 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9085 int arg2 ;
9086 int arg3 = (int) 0 ;
9087 void *argp1 = 0 ;
9088 int res1 = 0 ;
9089 int val2 ;
9090 int ecode2 = 0 ;
9091 int val3 ;
9092 int ecode3 = 0 ;
9093 PyObject * obj0 = 0 ;
9094 PyObject * obj1 = 0 ;
9095 PyObject * obj2 = 0 ;
9096 char * kwnames[] = {
9097 (char *) "self",(char *) "offset",(char *) "whence", NULL
9098 };
9099
9100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9102 if (!SWIG_IsOK(res1)) {
9103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9104 }
9105 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9106 ecode2 = SWIG_AsVal_int(obj1, &val2);
9107 if (!SWIG_IsOK(ecode2)) {
9108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9109 }
9110 arg2 = static_cast< int >(val2);
9111 if (obj2) {
9112 ecode3 = SWIG_AsVal_int(obj2, &val3);
9113 if (!SWIG_IsOK(ecode3)) {
9114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9115 }
9116 arg3 = static_cast< int >(val3);
9117 }
9118 {
9119 PyThreadState* __tstate = wxPyBeginAllowThreads();
9120 (arg1)->seek(arg2,arg3);
9121 wxPyEndAllowThreads(__tstate);
9122 if (PyErr_Occurred()) SWIG_fail;
9123 }
9124 resultobj = SWIG_Py_Void();
9125 return resultobj;
9126 fail:
9127 return NULL;
9128 }
9129
9130
9131 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9132 PyObject *resultobj = 0;
9133 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9134 int result;
9135 void *argp1 = 0 ;
9136 int res1 = 0 ;
9137 PyObject *swig_obj[1] ;
9138
9139 if (!args) SWIG_fail;
9140 swig_obj[0] = args;
9141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9142 if (!SWIG_IsOK(res1)) {
9143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9144 }
9145 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9146 {
9147 PyThreadState* __tstate = wxPyBeginAllowThreads();
9148 result = (int)(arg1)->tell();
9149 wxPyEndAllowThreads(__tstate);
9150 if (PyErr_Occurred()) SWIG_fail;
9151 }
9152 resultobj = SWIG_From_int(static_cast< int >(result));
9153 return resultobj;
9154 fail:
9155 return NULL;
9156 }
9157
9158
9159 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9160 PyObject *resultobj = 0;
9161 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9162 char result;
9163 void *argp1 = 0 ;
9164 int res1 = 0 ;
9165 PyObject *swig_obj[1] ;
9166
9167 if (!args) SWIG_fail;
9168 swig_obj[0] = args;
9169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9170 if (!SWIG_IsOK(res1)) {
9171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9172 }
9173 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9174 {
9175 PyThreadState* __tstate = wxPyBeginAllowThreads();
9176 result = (char)(arg1)->Peek();
9177 wxPyEndAllowThreads(__tstate);
9178 if (PyErr_Occurred()) SWIG_fail;
9179 }
9180 resultobj = SWIG_From_char(static_cast< char >(result));
9181 return resultobj;
9182 fail:
9183 return NULL;
9184 }
9185
9186
9187 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9188 PyObject *resultobj = 0;
9189 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9190 char result;
9191 void *argp1 = 0 ;
9192 int res1 = 0 ;
9193 PyObject *swig_obj[1] ;
9194
9195 if (!args) SWIG_fail;
9196 swig_obj[0] = args;
9197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9198 if (!SWIG_IsOK(res1)) {
9199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9200 }
9201 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9202 {
9203 PyThreadState* __tstate = wxPyBeginAllowThreads();
9204 result = (char)(arg1)->GetC();
9205 wxPyEndAllowThreads(__tstate);
9206 if (PyErr_Occurred()) SWIG_fail;
9207 }
9208 resultobj = SWIG_From_char(static_cast< char >(result));
9209 return resultobj;
9210 fail:
9211 return NULL;
9212 }
9213
9214
9215 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9216 PyObject *resultobj = 0;
9217 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9218 size_t result;
9219 void *argp1 = 0 ;
9220 int res1 = 0 ;
9221 PyObject *swig_obj[1] ;
9222
9223 if (!args) SWIG_fail;
9224 swig_obj[0] = args;
9225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9226 if (!SWIG_IsOK(res1)) {
9227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9228 }
9229 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9230 {
9231 PyThreadState* __tstate = wxPyBeginAllowThreads();
9232 result = (size_t)(arg1)->LastRead();
9233 wxPyEndAllowThreads(__tstate);
9234 if (PyErr_Occurred()) SWIG_fail;
9235 }
9236 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9237 return resultobj;
9238 fail:
9239 return NULL;
9240 }
9241
9242
9243 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9244 PyObject *resultobj = 0;
9245 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9246 bool result;
9247 void *argp1 = 0 ;
9248 int res1 = 0 ;
9249 PyObject *swig_obj[1] ;
9250
9251 if (!args) SWIG_fail;
9252 swig_obj[0] = args;
9253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9254 if (!SWIG_IsOK(res1)) {
9255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9256 }
9257 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9258 {
9259 PyThreadState* __tstate = wxPyBeginAllowThreads();
9260 result = (bool)(arg1)->CanRead();
9261 wxPyEndAllowThreads(__tstate);
9262 if (PyErr_Occurred()) SWIG_fail;
9263 }
9264 {
9265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9266 }
9267 return resultobj;
9268 fail:
9269 return NULL;
9270 }
9271
9272
9273 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9274 PyObject *resultobj = 0;
9275 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9276 bool result;
9277 void *argp1 = 0 ;
9278 int res1 = 0 ;
9279 PyObject *swig_obj[1] ;
9280
9281 if (!args) SWIG_fail;
9282 swig_obj[0] = args;
9283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9284 if (!SWIG_IsOK(res1)) {
9285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9286 }
9287 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9288 {
9289 PyThreadState* __tstate = wxPyBeginAllowThreads();
9290 result = (bool)(arg1)->Eof();
9291 wxPyEndAllowThreads(__tstate);
9292 if (PyErr_Occurred()) SWIG_fail;
9293 }
9294 {
9295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9296 }
9297 return resultobj;
9298 fail:
9299 return NULL;
9300 }
9301
9302
9303 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9304 PyObject *resultobj = 0;
9305 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9306 char arg2 ;
9307 bool result;
9308 void *argp1 = 0 ;
9309 int res1 = 0 ;
9310 char val2 ;
9311 int ecode2 = 0 ;
9312 PyObject * obj0 = 0 ;
9313 PyObject * obj1 = 0 ;
9314 char * kwnames[] = {
9315 (char *) "self",(char *) "c", NULL
9316 };
9317
9318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9320 if (!SWIG_IsOK(res1)) {
9321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9322 }
9323 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9324 ecode2 = SWIG_AsVal_char(obj1, &val2);
9325 if (!SWIG_IsOK(ecode2)) {
9326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9327 }
9328 arg2 = static_cast< char >(val2);
9329 {
9330 PyThreadState* __tstate = wxPyBeginAllowThreads();
9331 result = (bool)(arg1)->Ungetch(arg2);
9332 wxPyEndAllowThreads(__tstate);
9333 if (PyErr_Occurred()) SWIG_fail;
9334 }
9335 {
9336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9337 }
9338 return resultobj;
9339 fail:
9340 return NULL;
9341 }
9342
9343
9344 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9345 PyObject *resultobj = 0;
9346 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9347 long arg2 ;
9348 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9349 long result;
9350 void *argp1 = 0 ;
9351 int res1 = 0 ;
9352 long val2 ;
9353 int ecode2 = 0 ;
9354 int val3 ;
9355 int ecode3 = 0 ;
9356 PyObject * obj0 = 0 ;
9357 PyObject * obj1 = 0 ;
9358 PyObject * obj2 = 0 ;
9359 char * kwnames[] = {
9360 (char *) "self",(char *) "pos",(char *) "mode", NULL
9361 };
9362
9363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9365 if (!SWIG_IsOK(res1)) {
9366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9367 }
9368 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9369 ecode2 = SWIG_AsVal_long(obj1, &val2);
9370 if (!SWIG_IsOK(ecode2)) {
9371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9372 }
9373 arg2 = static_cast< long >(val2);
9374 if (obj2) {
9375 ecode3 = SWIG_AsVal_int(obj2, &val3);
9376 if (!SWIG_IsOK(ecode3)) {
9377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9378 }
9379 arg3 = static_cast< wxSeekMode >(val3);
9380 }
9381 {
9382 PyThreadState* __tstate = wxPyBeginAllowThreads();
9383 result = (long)(arg1)->SeekI(arg2,arg3);
9384 wxPyEndAllowThreads(__tstate);
9385 if (PyErr_Occurred()) SWIG_fail;
9386 }
9387 resultobj = SWIG_From_long(static_cast< long >(result));
9388 return resultobj;
9389 fail:
9390 return NULL;
9391 }
9392
9393
9394 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9395 PyObject *resultobj = 0;
9396 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9397 long result;
9398 void *argp1 = 0 ;
9399 int res1 = 0 ;
9400 PyObject *swig_obj[1] ;
9401
9402 if (!args) SWIG_fail;
9403 swig_obj[0] = args;
9404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9405 if (!SWIG_IsOK(res1)) {
9406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9407 }
9408 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9409 {
9410 PyThreadState* __tstate = wxPyBeginAllowThreads();
9411 result = (long)(arg1)->TellI();
9412 wxPyEndAllowThreads(__tstate);
9413 if (PyErr_Occurred()) SWIG_fail;
9414 }
9415 resultobj = SWIG_From_long(static_cast< long >(result));
9416 return resultobj;
9417 fail:
9418 return NULL;
9419 }
9420
9421
9422 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9423 PyObject *obj;
9424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9425 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9426 return SWIG_Py_Void();
9427 }
9428
9429 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9430 return SWIG_Python_InitShadowInstance(args);
9431 }
9432
9433 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9434 PyObject *resultobj = 0;
9435 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9436 PyObject *arg2 = (PyObject *) 0 ;
9437 void *argp1 = 0 ;
9438 int res1 = 0 ;
9439 PyObject * obj0 = 0 ;
9440 PyObject * obj1 = 0 ;
9441 char * kwnames[] = {
9442 (char *) "self",(char *) "obj", NULL
9443 };
9444
9445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9447 if (!SWIG_IsOK(res1)) {
9448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9449 }
9450 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9451 arg2 = obj1;
9452 {
9453 PyThreadState* __tstate = wxPyBeginAllowThreads();
9454 wxOutputStream_write(arg1,arg2);
9455 wxPyEndAllowThreads(__tstate);
9456 if (PyErr_Occurred()) SWIG_fail;
9457 }
9458 resultobj = SWIG_Py_Void();
9459 return resultobj;
9460 fail:
9461 return NULL;
9462 }
9463
9464
9465 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9466 PyObject *resultobj = 0;
9467 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9468 size_t result;
9469 void *argp1 = 0 ;
9470 int res1 = 0 ;
9471 PyObject *swig_obj[1] ;
9472
9473 if (!args) SWIG_fail;
9474 swig_obj[0] = args;
9475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9476 if (!SWIG_IsOK(res1)) {
9477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9478 }
9479 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9480 {
9481 PyThreadState* __tstate = wxPyBeginAllowThreads();
9482 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9483 wxPyEndAllowThreads(__tstate);
9484 if (PyErr_Occurred()) SWIG_fail;
9485 }
9486 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9487 return resultobj;
9488 fail:
9489 return NULL;
9490 }
9491
9492
9493 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9494 PyObject *obj;
9495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9496 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9497 return SWIG_Py_Void();
9498 }
9499
9500 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9501 PyObject *resultobj = 0;
9502 wxInputStream *arg1 = (wxInputStream *) 0 ;
9503 wxString *arg2 = 0 ;
9504 wxString *arg3 = 0 ;
9505 wxString *arg4 = 0 ;
9506 wxDateTime arg5 ;
9507 wxFSFile *result = 0 ;
9508 wxPyInputStream *temp1 ;
9509 bool temp2 = false ;
9510 bool temp3 = false ;
9511 bool temp4 = false ;
9512 void *argp5 ;
9513 int res5 = 0 ;
9514 PyObject * obj0 = 0 ;
9515 PyObject * obj1 = 0 ;
9516 PyObject * obj2 = 0 ;
9517 PyObject * obj3 = 0 ;
9518 PyObject * obj4 = 0 ;
9519 char * kwnames[] = {
9520 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9521 };
9522
9523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9524 {
9525 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9526 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9527 } else {
9528 PyErr_Clear(); // clear the failure of the wxPyConvert above
9529 arg1 = wxPyCBInputStream_create(obj0, true);
9530 if (arg1 == NULL) {
9531 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9532 SWIG_fail;
9533 }
9534 }
9535 }
9536 {
9537 arg2 = wxString_in_helper(obj1);
9538 if (arg2 == NULL) SWIG_fail;
9539 temp2 = true;
9540 }
9541 {
9542 arg3 = wxString_in_helper(obj2);
9543 if (arg3 == NULL) SWIG_fail;
9544 temp3 = true;
9545 }
9546 {
9547 arg4 = wxString_in_helper(obj3);
9548 if (arg4 == NULL) SWIG_fail;
9549 temp4 = true;
9550 }
9551 {
9552 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9553 if (!SWIG_IsOK(res5)) {
9554 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9555 }
9556 if (!argp5) {
9557 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9558 } else {
9559 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9560 arg5 = *temp;
9561 if (SWIG_IsNewObj(res5)) delete temp;
9562 }
9563 }
9564 {
9565 PyThreadState* __tstate = wxPyBeginAllowThreads();
9566 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9567 wxPyEndAllowThreads(__tstate);
9568 if (PyErr_Occurred()) SWIG_fail;
9569 }
9570 {
9571 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9572 }
9573 {
9574 if (temp2)
9575 delete arg2;
9576 }
9577 {
9578 if (temp3)
9579 delete arg3;
9580 }
9581 {
9582 if (temp4)
9583 delete arg4;
9584 }
9585 return resultobj;
9586 fail:
9587 {
9588 if (temp2)
9589 delete arg2;
9590 }
9591 {
9592 if (temp3)
9593 delete arg3;
9594 }
9595 {
9596 if (temp4)
9597 delete arg4;
9598 }
9599 return NULL;
9600 }
9601
9602
9603 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9604 PyObject *resultobj = 0;
9605 wxFSFile *arg1 = (wxFSFile *) 0 ;
9606 void *argp1 = 0 ;
9607 int res1 = 0 ;
9608 PyObject *swig_obj[1] ;
9609
9610 if (!args) SWIG_fail;
9611 swig_obj[0] = args;
9612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9613 if (!SWIG_IsOK(res1)) {
9614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9615 }
9616 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9617 {
9618 PyThreadState* __tstate = wxPyBeginAllowThreads();
9619 delete arg1;
9620
9621 wxPyEndAllowThreads(__tstate);
9622 if (PyErr_Occurred()) SWIG_fail;
9623 }
9624 resultobj = SWIG_Py_Void();
9625 return resultobj;
9626 fail:
9627 return NULL;
9628 }
9629
9630
9631 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9632 PyObject *resultobj = 0;
9633 wxFSFile *arg1 = (wxFSFile *) 0 ;
9634 wxInputStream *result = 0 ;
9635 void *argp1 = 0 ;
9636 int res1 = 0 ;
9637 PyObject *swig_obj[1] ;
9638
9639 if (!args) SWIG_fail;
9640 swig_obj[0] = args;
9641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9642 if (!SWIG_IsOK(res1)) {
9643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9644 }
9645 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9646 {
9647 PyThreadState* __tstate = wxPyBeginAllowThreads();
9648 result = (wxInputStream *)(arg1)->GetStream();
9649 wxPyEndAllowThreads(__tstate);
9650 if (PyErr_Occurred()) SWIG_fail;
9651 }
9652 {
9653 wxPyInputStream * _ptr = NULL;
9654
9655 if (result) {
9656 _ptr = new wxPyInputStream(result);
9657 }
9658 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9659 }
9660 return resultobj;
9661 fail:
9662 return NULL;
9663 }
9664
9665
9666 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9667 PyObject *resultobj = 0;
9668 wxFSFile *arg1 = (wxFSFile *) 0 ;
9669 wxString *result = 0 ;
9670 void *argp1 = 0 ;
9671 int res1 = 0 ;
9672 PyObject *swig_obj[1] ;
9673
9674 if (!args) SWIG_fail;
9675 swig_obj[0] = args;
9676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9677 if (!SWIG_IsOK(res1)) {
9678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9679 }
9680 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 {
9684 wxString const &_result_ref = (arg1)->GetMimeType();
9685 result = (wxString *) &_result_ref;
9686 }
9687 wxPyEndAllowThreads(__tstate);
9688 if (PyErr_Occurred()) SWIG_fail;
9689 }
9690 {
9691 #if wxUSE_UNICODE
9692 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9693 #else
9694 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9695 #endif
9696 }
9697 return resultobj;
9698 fail:
9699 return NULL;
9700 }
9701
9702
9703 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9704 PyObject *resultobj = 0;
9705 wxFSFile *arg1 = (wxFSFile *) 0 ;
9706 wxString *result = 0 ;
9707 void *argp1 = 0 ;
9708 int res1 = 0 ;
9709 PyObject *swig_obj[1] ;
9710
9711 if (!args) SWIG_fail;
9712 swig_obj[0] = args;
9713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9714 if (!SWIG_IsOK(res1)) {
9715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9716 }
9717 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9718 {
9719 PyThreadState* __tstate = wxPyBeginAllowThreads();
9720 {
9721 wxString const &_result_ref = (arg1)->GetLocation();
9722 result = (wxString *) &_result_ref;
9723 }
9724 wxPyEndAllowThreads(__tstate);
9725 if (PyErr_Occurred()) SWIG_fail;
9726 }
9727 {
9728 #if wxUSE_UNICODE
9729 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9730 #else
9731 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9732 #endif
9733 }
9734 return resultobj;
9735 fail:
9736 return NULL;
9737 }
9738
9739
9740 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9741 PyObject *resultobj = 0;
9742 wxFSFile *arg1 = (wxFSFile *) 0 ;
9743 wxString *result = 0 ;
9744 void *argp1 = 0 ;
9745 int res1 = 0 ;
9746 PyObject *swig_obj[1] ;
9747
9748 if (!args) SWIG_fail;
9749 swig_obj[0] = args;
9750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9751 if (!SWIG_IsOK(res1)) {
9752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9753 }
9754 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9755 {
9756 PyThreadState* __tstate = wxPyBeginAllowThreads();
9757 {
9758 wxString const &_result_ref = (arg1)->GetAnchor();
9759 result = (wxString *) &_result_ref;
9760 }
9761 wxPyEndAllowThreads(__tstate);
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 {
9765 #if wxUSE_UNICODE
9766 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9767 #else
9768 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9769 #endif
9770 }
9771 return resultobj;
9772 fail:
9773 return NULL;
9774 }
9775
9776
9777 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9778 PyObject *resultobj = 0;
9779 wxFSFile *arg1 = (wxFSFile *) 0 ;
9780 wxDateTime result;
9781 void *argp1 = 0 ;
9782 int res1 = 0 ;
9783 PyObject *swig_obj[1] ;
9784
9785 if (!args) SWIG_fail;
9786 swig_obj[0] = args;
9787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9788 if (!SWIG_IsOK(res1)) {
9789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9790 }
9791 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9792 {
9793 PyThreadState* __tstate = wxPyBeginAllowThreads();
9794 result = (arg1)->GetModificationTime();
9795 wxPyEndAllowThreads(__tstate);
9796 if (PyErr_Occurred()) SWIG_fail;
9797 }
9798 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9799 return resultobj;
9800 fail:
9801 return NULL;
9802 }
9803
9804
9805 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9806 PyObject *obj;
9807 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9808 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9809 return SWIG_Py_Void();
9810 }
9811
9812 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9813 return SWIG_Python_InitShadowInstance(args);
9814 }
9815
9816 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9817 PyObject *obj;
9818 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9819 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9820 return SWIG_Py_Void();
9821 }
9822
9823 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9824 PyObject *resultobj = 0;
9825 wxPyFileSystemHandler *result = 0 ;
9826
9827 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9828 {
9829 PyThreadState* __tstate = wxPyBeginAllowThreads();
9830 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9831 wxPyEndAllowThreads(__tstate);
9832 if (PyErr_Occurred()) SWIG_fail;
9833 }
9834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9835 return resultobj;
9836 fail:
9837 return NULL;
9838 }
9839
9840
9841 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9842 PyObject *resultobj = 0;
9843 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9844 PyObject *arg2 = (PyObject *) 0 ;
9845 PyObject *arg3 = (PyObject *) 0 ;
9846 void *argp1 = 0 ;
9847 int res1 = 0 ;
9848 PyObject * obj0 = 0 ;
9849 PyObject * obj1 = 0 ;
9850 PyObject * obj2 = 0 ;
9851 char * kwnames[] = {
9852 (char *) "self",(char *) "self",(char *) "_class", NULL
9853 };
9854
9855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9857 if (!SWIG_IsOK(res1)) {
9858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9859 }
9860 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9861 arg2 = obj1;
9862 arg3 = obj2;
9863 {
9864 PyThreadState* __tstate = wxPyBeginAllowThreads();
9865 (arg1)->_setCallbackInfo(arg2,arg3);
9866 wxPyEndAllowThreads(__tstate);
9867 if (PyErr_Occurred()) SWIG_fail;
9868 }
9869 resultobj = SWIG_Py_Void();
9870 return resultobj;
9871 fail:
9872 return NULL;
9873 }
9874
9875
9876 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9877 PyObject *resultobj = 0;
9878 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9879 wxString *arg2 = 0 ;
9880 bool result;
9881 void *argp1 = 0 ;
9882 int res1 = 0 ;
9883 bool temp2 = false ;
9884 PyObject * obj0 = 0 ;
9885 PyObject * obj1 = 0 ;
9886 char * kwnames[] = {
9887 (char *) "self",(char *) "location", NULL
9888 };
9889
9890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9892 if (!SWIG_IsOK(res1)) {
9893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9894 }
9895 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9896 {
9897 arg2 = wxString_in_helper(obj1);
9898 if (arg2 == NULL) SWIG_fail;
9899 temp2 = true;
9900 }
9901 {
9902 PyThreadState* __tstate = wxPyBeginAllowThreads();
9903 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9904 wxPyEndAllowThreads(__tstate);
9905 if (PyErr_Occurred()) SWIG_fail;
9906 }
9907 {
9908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9909 }
9910 {
9911 if (temp2)
9912 delete arg2;
9913 }
9914 return resultobj;
9915 fail:
9916 {
9917 if (temp2)
9918 delete arg2;
9919 }
9920 return NULL;
9921 }
9922
9923
9924 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9925 PyObject *resultobj = 0;
9926 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9927 wxFileSystem *arg2 = 0 ;
9928 wxString *arg3 = 0 ;
9929 wxFSFile *result = 0 ;
9930 void *argp1 = 0 ;
9931 int res1 = 0 ;
9932 void *argp2 = 0 ;
9933 int res2 = 0 ;
9934 bool temp3 = false ;
9935 PyObject * obj0 = 0 ;
9936 PyObject * obj1 = 0 ;
9937 PyObject * obj2 = 0 ;
9938 char * kwnames[] = {
9939 (char *) "self",(char *) "fs",(char *) "location", NULL
9940 };
9941
9942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9944 if (!SWIG_IsOK(res1)) {
9945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9946 }
9947 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9948 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
9949 if (!SWIG_IsOK(res2)) {
9950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9951 }
9952 if (!argp2) {
9953 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9954 }
9955 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
9956 {
9957 arg3 = wxString_in_helper(obj2);
9958 if (arg3 == NULL) SWIG_fail;
9959 temp3 = true;
9960 }
9961 {
9962 PyThreadState* __tstate = wxPyBeginAllowThreads();
9963 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9964 wxPyEndAllowThreads(__tstate);
9965 if (PyErr_Occurred()) SWIG_fail;
9966 }
9967 {
9968 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
9969 }
9970 {
9971 if (temp3)
9972 delete arg3;
9973 }
9974 return resultobj;
9975 fail:
9976 {
9977 if (temp3)
9978 delete arg3;
9979 }
9980 return NULL;
9981 }
9982
9983
9984 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9985 PyObject *resultobj = 0;
9986 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9987 wxString *arg2 = 0 ;
9988 int arg3 = (int) 0 ;
9989 wxString result;
9990 void *argp1 = 0 ;
9991 int res1 = 0 ;
9992 bool temp2 = false ;
9993 int val3 ;
9994 int ecode3 = 0 ;
9995 PyObject * obj0 = 0 ;
9996 PyObject * obj1 = 0 ;
9997 PyObject * obj2 = 0 ;
9998 char * kwnames[] = {
9999 (char *) "self",(char *) "spec",(char *) "flags", NULL
10000 };
10001
10002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10004 if (!SWIG_IsOK(res1)) {
10005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10006 }
10007 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10008 {
10009 arg2 = wxString_in_helper(obj1);
10010 if (arg2 == NULL) SWIG_fail;
10011 temp2 = true;
10012 }
10013 if (obj2) {
10014 ecode3 = SWIG_AsVal_int(obj2, &val3);
10015 if (!SWIG_IsOK(ecode3)) {
10016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10017 }
10018 arg3 = static_cast< int >(val3);
10019 }
10020 {
10021 PyThreadState* __tstate = wxPyBeginAllowThreads();
10022 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10023 wxPyEndAllowThreads(__tstate);
10024 if (PyErr_Occurred()) SWIG_fail;
10025 }
10026 {
10027 #if wxUSE_UNICODE
10028 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10029 #else
10030 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10031 #endif
10032 }
10033 {
10034 if (temp2)
10035 delete arg2;
10036 }
10037 return resultobj;
10038 fail:
10039 {
10040 if (temp2)
10041 delete arg2;
10042 }
10043 return NULL;
10044 }
10045
10046
10047 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10048 PyObject *resultobj = 0;
10049 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10050 wxString result;
10051 void *argp1 = 0 ;
10052 int res1 = 0 ;
10053 PyObject *swig_obj[1] ;
10054
10055 if (!args) SWIG_fail;
10056 swig_obj[0] = args;
10057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10058 if (!SWIG_IsOK(res1)) {
10059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10060 }
10061 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10062 {
10063 PyThreadState* __tstate = wxPyBeginAllowThreads();
10064 result = (arg1)->FindNext();
10065 wxPyEndAllowThreads(__tstate);
10066 if (PyErr_Occurred()) SWIG_fail;
10067 }
10068 {
10069 #if wxUSE_UNICODE
10070 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10071 #else
10072 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10073 #endif
10074 }
10075 return resultobj;
10076 fail:
10077 return NULL;
10078 }
10079
10080
10081 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10082 PyObject *resultobj = 0;
10083 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10084 wxString *arg2 = 0 ;
10085 wxString result;
10086 void *argp1 = 0 ;
10087 int res1 = 0 ;
10088 bool temp2 = false ;
10089 PyObject * obj0 = 0 ;
10090 PyObject * obj1 = 0 ;
10091 char * kwnames[] = {
10092 (char *) "self",(char *) "location", NULL
10093 };
10094
10095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10097 if (!SWIG_IsOK(res1)) {
10098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10099 }
10100 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10101 {
10102 arg2 = wxString_in_helper(obj1);
10103 if (arg2 == NULL) SWIG_fail;
10104 temp2 = true;
10105 }
10106 {
10107 PyThreadState* __tstate = wxPyBeginAllowThreads();
10108 result = (arg1)->GetProtocol((wxString const &)*arg2);
10109 wxPyEndAllowThreads(__tstate);
10110 if (PyErr_Occurred()) SWIG_fail;
10111 }
10112 {
10113 #if wxUSE_UNICODE
10114 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10115 #else
10116 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10117 #endif
10118 }
10119 {
10120 if (temp2)
10121 delete arg2;
10122 }
10123 return resultobj;
10124 fail:
10125 {
10126 if (temp2)
10127 delete arg2;
10128 }
10129 return NULL;
10130 }
10131
10132
10133 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10134 PyObject *resultobj = 0;
10135 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10136 wxString *arg2 = 0 ;
10137 wxString result;
10138 void *argp1 = 0 ;
10139 int res1 = 0 ;
10140 bool temp2 = false ;
10141 PyObject * obj0 = 0 ;
10142 PyObject * obj1 = 0 ;
10143 char * kwnames[] = {
10144 (char *) "self",(char *) "location", NULL
10145 };
10146
10147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10149 if (!SWIG_IsOK(res1)) {
10150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10151 }
10152 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10153 {
10154 arg2 = wxString_in_helper(obj1);
10155 if (arg2 == NULL) SWIG_fail;
10156 temp2 = true;
10157 }
10158 {
10159 PyThreadState* __tstate = wxPyBeginAllowThreads();
10160 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10161 wxPyEndAllowThreads(__tstate);
10162 if (PyErr_Occurred()) SWIG_fail;
10163 }
10164 {
10165 #if wxUSE_UNICODE
10166 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10167 #else
10168 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10169 #endif
10170 }
10171 {
10172 if (temp2)
10173 delete arg2;
10174 }
10175 return resultobj;
10176 fail:
10177 {
10178 if (temp2)
10179 delete arg2;
10180 }
10181 return NULL;
10182 }
10183
10184
10185 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10186 PyObject *resultobj = 0;
10187 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10188 wxString *arg2 = 0 ;
10189 wxString result;
10190 void *argp1 = 0 ;
10191 int res1 = 0 ;
10192 bool temp2 = false ;
10193 PyObject * obj0 = 0 ;
10194 PyObject * obj1 = 0 ;
10195 char * kwnames[] = {
10196 (char *) "self",(char *) "location", NULL
10197 };
10198
10199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10201 if (!SWIG_IsOK(res1)) {
10202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10203 }
10204 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10205 {
10206 arg2 = wxString_in_helper(obj1);
10207 if (arg2 == NULL) SWIG_fail;
10208 temp2 = true;
10209 }
10210 {
10211 PyThreadState* __tstate = wxPyBeginAllowThreads();
10212 result = (arg1)->GetAnchor((wxString const &)*arg2);
10213 wxPyEndAllowThreads(__tstate);
10214 if (PyErr_Occurred()) SWIG_fail;
10215 }
10216 {
10217 #if wxUSE_UNICODE
10218 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10219 #else
10220 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10221 #endif
10222 }
10223 {
10224 if (temp2)
10225 delete arg2;
10226 }
10227 return resultobj;
10228 fail:
10229 {
10230 if (temp2)
10231 delete arg2;
10232 }
10233 return NULL;
10234 }
10235
10236
10237 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10238 PyObject *resultobj = 0;
10239 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10240 wxString *arg2 = 0 ;
10241 wxString result;
10242 void *argp1 = 0 ;
10243 int res1 = 0 ;
10244 bool temp2 = false ;
10245 PyObject * obj0 = 0 ;
10246 PyObject * obj1 = 0 ;
10247 char * kwnames[] = {
10248 (char *) "self",(char *) "location", NULL
10249 };
10250
10251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10253 if (!SWIG_IsOK(res1)) {
10254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10255 }
10256 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10257 {
10258 arg2 = wxString_in_helper(obj1);
10259 if (arg2 == NULL) SWIG_fail;
10260 temp2 = true;
10261 }
10262 {
10263 PyThreadState* __tstate = wxPyBeginAllowThreads();
10264 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10265 wxPyEndAllowThreads(__tstate);
10266 if (PyErr_Occurred()) SWIG_fail;
10267 }
10268 {
10269 #if wxUSE_UNICODE
10270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10271 #else
10272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10273 #endif
10274 }
10275 {
10276 if (temp2)
10277 delete arg2;
10278 }
10279 return resultobj;
10280 fail:
10281 {
10282 if (temp2)
10283 delete arg2;
10284 }
10285 return NULL;
10286 }
10287
10288
10289 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10290 PyObject *resultobj = 0;
10291 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10292 wxString *arg2 = 0 ;
10293 wxString result;
10294 void *argp1 = 0 ;
10295 int res1 = 0 ;
10296 bool temp2 = false ;
10297 PyObject * obj0 = 0 ;
10298 PyObject * obj1 = 0 ;
10299 char * kwnames[] = {
10300 (char *) "self",(char *) "location", NULL
10301 };
10302
10303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10305 if (!SWIG_IsOK(res1)) {
10306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10307 }
10308 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10309 {
10310 arg2 = wxString_in_helper(obj1);
10311 if (arg2 == NULL) SWIG_fail;
10312 temp2 = true;
10313 }
10314 {
10315 PyThreadState* __tstate = wxPyBeginAllowThreads();
10316 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10317 wxPyEndAllowThreads(__tstate);
10318 if (PyErr_Occurred()) SWIG_fail;
10319 }
10320 {
10321 #if wxUSE_UNICODE
10322 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10323 #else
10324 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10325 #endif
10326 }
10327 {
10328 if (temp2)
10329 delete arg2;
10330 }
10331 return resultobj;
10332 fail:
10333 {
10334 if (temp2)
10335 delete arg2;
10336 }
10337 return NULL;
10338 }
10339
10340
10341 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10342 PyObject *obj;
10343 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10344 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10345 return SWIG_Py_Void();
10346 }
10347
10348 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10349 return SWIG_Python_InitShadowInstance(args);
10350 }
10351
10352 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10353 PyObject *resultobj = 0;
10354 wxFileSystem *result = 0 ;
10355
10356 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10357 {
10358 PyThreadState* __tstate = wxPyBeginAllowThreads();
10359 result = (wxFileSystem *)new wxFileSystem();
10360 wxPyEndAllowThreads(__tstate);
10361 if (PyErr_Occurred()) SWIG_fail;
10362 }
10363 {
10364 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10365 }
10366 return resultobj;
10367 fail:
10368 return NULL;
10369 }
10370
10371
10372 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10373 PyObject *resultobj = 0;
10374 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10375 void *argp1 = 0 ;
10376 int res1 = 0 ;
10377 PyObject *swig_obj[1] ;
10378
10379 if (!args) SWIG_fail;
10380 swig_obj[0] = args;
10381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10382 if (!SWIG_IsOK(res1)) {
10383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10384 }
10385 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10386 {
10387 PyThreadState* __tstate = wxPyBeginAllowThreads();
10388 delete arg1;
10389
10390 wxPyEndAllowThreads(__tstate);
10391 if (PyErr_Occurred()) SWIG_fail;
10392 }
10393 resultobj = SWIG_Py_Void();
10394 return resultobj;
10395 fail:
10396 return NULL;
10397 }
10398
10399
10400 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10401 PyObject *resultobj = 0;
10402 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10403 wxString *arg2 = 0 ;
10404 bool arg3 = (bool) false ;
10405 void *argp1 = 0 ;
10406 int res1 = 0 ;
10407 bool temp2 = false ;
10408 bool val3 ;
10409 int ecode3 = 0 ;
10410 PyObject * obj0 = 0 ;
10411 PyObject * obj1 = 0 ;
10412 PyObject * obj2 = 0 ;
10413 char * kwnames[] = {
10414 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10415 };
10416
10417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10419 if (!SWIG_IsOK(res1)) {
10420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10421 }
10422 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10423 {
10424 arg2 = wxString_in_helper(obj1);
10425 if (arg2 == NULL) SWIG_fail;
10426 temp2 = true;
10427 }
10428 if (obj2) {
10429 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10430 if (!SWIG_IsOK(ecode3)) {
10431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10432 }
10433 arg3 = static_cast< bool >(val3);
10434 }
10435 {
10436 PyThreadState* __tstate = wxPyBeginAllowThreads();
10437 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10438 wxPyEndAllowThreads(__tstate);
10439 if (PyErr_Occurred()) SWIG_fail;
10440 }
10441 resultobj = SWIG_Py_Void();
10442 {
10443 if (temp2)
10444 delete arg2;
10445 }
10446 return resultobj;
10447 fail:
10448 {
10449 if (temp2)
10450 delete arg2;
10451 }
10452 return NULL;
10453 }
10454
10455
10456 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10457 PyObject *resultobj = 0;
10458 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10459 wxString result;
10460 void *argp1 = 0 ;
10461 int res1 = 0 ;
10462 PyObject *swig_obj[1] ;
10463
10464 if (!args) SWIG_fail;
10465 swig_obj[0] = args;
10466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10467 if (!SWIG_IsOK(res1)) {
10468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10469 }
10470 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10471 {
10472 PyThreadState* __tstate = wxPyBeginAllowThreads();
10473 result = (arg1)->GetPath();
10474 wxPyEndAllowThreads(__tstate);
10475 if (PyErr_Occurred()) SWIG_fail;
10476 }
10477 {
10478 #if wxUSE_UNICODE
10479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10480 #else
10481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10482 #endif
10483 }
10484 return resultobj;
10485 fail:
10486 return NULL;
10487 }
10488
10489
10490 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10491 PyObject *resultobj = 0;
10492 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10493 wxString *arg2 = 0 ;
10494 wxFSFile *result = 0 ;
10495 void *argp1 = 0 ;
10496 int res1 = 0 ;
10497 bool temp2 = false ;
10498 PyObject * obj0 = 0 ;
10499 PyObject * obj1 = 0 ;
10500 char * kwnames[] = {
10501 (char *) "self",(char *) "location", NULL
10502 };
10503
10504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10506 if (!SWIG_IsOK(res1)) {
10507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10508 }
10509 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10510 {
10511 arg2 = wxString_in_helper(obj1);
10512 if (arg2 == NULL) SWIG_fail;
10513 temp2 = true;
10514 }
10515 {
10516 PyThreadState* __tstate = wxPyBeginAllowThreads();
10517 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10518 wxPyEndAllowThreads(__tstate);
10519 if (PyErr_Occurred()) SWIG_fail;
10520 }
10521 {
10522 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10523 }
10524 {
10525 if (temp2)
10526 delete arg2;
10527 }
10528 return resultobj;
10529 fail:
10530 {
10531 if (temp2)
10532 delete arg2;
10533 }
10534 return NULL;
10535 }
10536
10537
10538 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10539 PyObject *resultobj = 0;
10540 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10541 wxString *arg2 = 0 ;
10542 int arg3 = (int) 0 ;
10543 wxString result;
10544 void *argp1 = 0 ;
10545 int res1 = 0 ;
10546 bool temp2 = false ;
10547 int val3 ;
10548 int ecode3 = 0 ;
10549 PyObject * obj0 = 0 ;
10550 PyObject * obj1 = 0 ;
10551 PyObject * obj2 = 0 ;
10552 char * kwnames[] = {
10553 (char *) "self",(char *) "spec",(char *) "flags", NULL
10554 };
10555
10556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10558 if (!SWIG_IsOK(res1)) {
10559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10560 }
10561 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10562 {
10563 arg2 = wxString_in_helper(obj1);
10564 if (arg2 == NULL) SWIG_fail;
10565 temp2 = true;
10566 }
10567 if (obj2) {
10568 ecode3 = SWIG_AsVal_int(obj2, &val3);
10569 if (!SWIG_IsOK(ecode3)) {
10570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10571 }
10572 arg3 = static_cast< int >(val3);
10573 }
10574 {
10575 PyThreadState* __tstate = wxPyBeginAllowThreads();
10576 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10577 wxPyEndAllowThreads(__tstate);
10578 if (PyErr_Occurred()) SWIG_fail;
10579 }
10580 {
10581 #if wxUSE_UNICODE
10582 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10583 #else
10584 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10585 #endif
10586 }
10587 {
10588 if (temp2)
10589 delete arg2;
10590 }
10591 return resultobj;
10592 fail:
10593 {
10594 if (temp2)
10595 delete arg2;
10596 }
10597 return NULL;
10598 }
10599
10600
10601 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10602 PyObject *resultobj = 0;
10603 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10604 wxString result;
10605 void *argp1 = 0 ;
10606 int res1 = 0 ;
10607 PyObject *swig_obj[1] ;
10608
10609 if (!args) SWIG_fail;
10610 swig_obj[0] = args;
10611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10612 if (!SWIG_IsOK(res1)) {
10613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10614 }
10615 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10616 {
10617 PyThreadState* __tstate = wxPyBeginAllowThreads();
10618 result = (arg1)->FindNext();
10619 wxPyEndAllowThreads(__tstate);
10620 if (PyErr_Occurred()) SWIG_fail;
10621 }
10622 {
10623 #if wxUSE_UNICODE
10624 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10625 #else
10626 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10627 #endif
10628 }
10629 return resultobj;
10630 fail:
10631 return NULL;
10632 }
10633
10634
10635 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10636 PyObject *resultobj = 0;
10637 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10638 void *argp1 = 0 ;
10639 int res1 = 0 ;
10640 PyObject * obj0 = 0 ;
10641 char * kwnames[] = {
10642 (char *) "handler", NULL
10643 };
10644
10645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
10647 if (!SWIG_IsOK(res1)) {
10648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10649 }
10650 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10651 {
10652 PyThreadState* __tstate = wxPyBeginAllowThreads();
10653 wxFileSystem::AddHandler(arg1);
10654 wxPyEndAllowThreads(__tstate);
10655 if (PyErr_Occurred()) SWIG_fail;
10656 }
10657 resultobj = SWIG_Py_Void();
10658 return resultobj;
10659 fail:
10660 return NULL;
10661 }
10662
10663
10664 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10665 PyObject *resultobj = 0;
10666
10667 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10668 {
10669 PyThreadState* __tstate = wxPyBeginAllowThreads();
10670 wxFileSystem::CleanUpHandlers();
10671 wxPyEndAllowThreads(__tstate);
10672 if (PyErr_Occurred()) SWIG_fail;
10673 }
10674 resultobj = SWIG_Py_Void();
10675 return resultobj;
10676 fail:
10677 return NULL;
10678 }
10679
10680
10681 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10682 PyObject *resultobj = 0;
10683 wxString *arg1 = 0 ;
10684 wxString result;
10685 bool temp1 = false ;
10686 PyObject * obj0 = 0 ;
10687 char * kwnames[] = {
10688 (char *) "filename", NULL
10689 };
10690
10691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10692 {
10693 arg1 = wxString_in_helper(obj0);
10694 if (arg1 == NULL) SWIG_fail;
10695 temp1 = true;
10696 }
10697 {
10698 PyThreadState* __tstate = wxPyBeginAllowThreads();
10699 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10700 wxPyEndAllowThreads(__tstate);
10701 if (PyErr_Occurred()) SWIG_fail;
10702 }
10703 {
10704 #if wxUSE_UNICODE
10705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10706 #else
10707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10708 #endif
10709 }
10710 {
10711 if (temp1)
10712 delete arg1;
10713 }
10714 return resultobj;
10715 fail:
10716 {
10717 if (temp1)
10718 delete arg1;
10719 }
10720 return NULL;
10721 }
10722
10723
10724 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10725 PyObject *resultobj = 0;
10726 wxString *arg1 = 0 ;
10727 wxString result;
10728 bool temp1 = false ;
10729 PyObject * obj0 = 0 ;
10730 char * kwnames[] = {
10731 (char *) "url", NULL
10732 };
10733
10734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10735 {
10736 arg1 = wxString_in_helper(obj0);
10737 if (arg1 == NULL) SWIG_fail;
10738 temp1 = true;
10739 }
10740 {
10741 PyThreadState* __tstate = wxPyBeginAllowThreads();
10742 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10743 wxPyEndAllowThreads(__tstate);
10744 if (PyErr_Occurred()) SWIG_fail;
10745 }
10746 {
10747 #if wxUSE_UNICODE
10748 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10749 #else
10750 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10751 #endif
10752 }
10753 {
10754 if (temp1)
10755 delete arg1;
10756 }
10757 return resultobj;
10758 fail:
10759 {
10760 if (temp1)
10761 delete arg1;
10762 }
10763 return NULL;
10764 }
10765
10766
10767 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10768 PyObject *obj;
10769 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10770 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10771 return SWIG_Py_Void();
10772 }
10773
10774 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10775 return SWIG_Python_InitShadowInstance(args);
10776 }
10777
10778 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10779 PyObject *resultobj = 0;
10780 wxInternetFSHandler *result = 0 ;
10781
10782 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10783 {
10784 PyThreadState* __tstate = wxPyBeginAllowThreads();
10785 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10786 wxPyEndAllowThreads(__tstate);
10787 if (PyErr_Occurred()) SWIG_fail;
10788 }
10789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10790 return resultobj;
10791 fail:
10792 return NULL;
10793 }
10794
10795
10796 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10797 PyObject *resultobj = 0;
10798 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10799 wxString *arg2 = 0 ;
10800 bool result;
10801 void *argp1 = 0 ;
10802 int res1 = 0 ;
10803 bool temp2 = false ;
10804 PyObject * obj0 = 0 ;
10805 PyObject * obj1 = 0 ;
10806 char * kwnames[] = {
10807 (char *) "self",(char *) "location", NULL
10808 };
10809
10810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10812 if (!SWIG_IsOK(res1)) {
10813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10814 }
10815 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10816 {
10817 arg2 = wxString_in_helper(obj1);
10818 if (arg2 == NULL) SWIG_fail;
10819 temp2 = true;
10820 }
10821 {
10822 PyThreadState* __tstate = wxPyBeginAllowThreads();
10823 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10824 wxPyEndAllowThreads(__tstate);
10825 if (PyErr_Occurred()) SWIG_fail;
10826 }
10827 {
10828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10829 }
10830 {
10831 if (temp2)
10832 delete arg2;
10833 }
10834 return resultobj;
10835 fail:
10836 {
10837 if (temp2)
10838 delete arg2;
10839 }
10840 return NULL;
10841 }
10842
10843
10844 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10845 PyObject *resultobj = 0;
10846 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10847 wxFileSystem *arg2 = 0 ;
10848 wxString *arg3 = 0 ;
10849 wxFSFile *result = 0 ;
10850 void *argp1 = 0 ;
10851 int res1 = 0 ;
10852 void *argp2 = 0 ;
10853 int res2 = 0 ;
10854 bool temp3 = false ;
10855 PyObject * obj0 = 0 ;
10856 PyObject * obj1 = 0 ;
10857 PyObject * obj2 = 0 ;
10858 char * kwnames[] = {
10859 (char *) "self",(char *) "fs",(char *) "location", NULL
10860 };
10861
10862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10864 if (!SWIG_IsOK(res1)) {
10865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10866 }
10867 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10868 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10869 if (!SWIG_IsOK(res2)) {
10870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10871 }
10872 if (!argp2) {
10873 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10874 }
10875 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10876 {
10877 arg3 = wxString_in_helper(obj2);
10878 if (arg3 == NULL) SWIG_fail;
10879 temp3 = true;
10880 }
10881 {
10882 PyThreadState* __tstate = wxPyBeginAllowThreads();
10883 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10884 wxPyEndAllowThreads(__tstate);
10885 if (PyErr_Occurred()) SWIG_fail;
10886 }
10887 {
10888 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10889 }
10890 {
10891 if (temp3)
10892 delete arg3;
10893 }
10894 return resultobj;
10895 fail:
10896 {
10897 if (temp3)
10898 delete arg3;
10899 }
10900 return NULL;
10901 }
10902
10903
10904 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10905 PyObject *obj;
10906 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10907 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
10908 return SWIG_Py_Void();
10909 }
10910
10911 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10912 return SWIG_Python_InitShadowInstance(args);
10913 }
10914
10915 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10916 PyObject *resultobj = 0;
10917 wxZipFSHandler *result = 0 ;
10918
10919 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
10920 {
10921 PyThreadState* __tstate = wxPyBeginAllowThreads();
10922 result = (wxZipFSHandler *)new wxZipFSHandler();
10923 wxPyEndAllowThreads(__tstate);
10924 if (PyErr_Occurred()) SWIG_fail;
10925 }
10926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
10927 return resultobj;
10928 fail:
10929 return NULL;
10930 }
10931
10932
10933 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10934 PyObject *resultobj = 0;
10935 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
10936 wxString *arg2 = 0 ;
10937 bool result;
10938 void *argp1 = 0 ;
10939 int res1 = 0 ;
10940 bool temp2 = false ;
10941 PyObject * obj0 = 0 ;
10942 PyObject * obj1 = 0 ;
10943 char * kwnames[] = {
10944 (char *) "self",(char *) "location", NULL
10945 };
10946
10947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
10949 if (!SWIG_IsOK(res1)) {
10950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
10951 }
10952 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
10953 {
10954 arg2 = wxString_in_helper(obj1);
10955 if (arg2 == NULL) SWIG_fail;
10956 temp2 = true;
10957 }
10958 {
10959 PyThreadState* __tstate = wxPyBeginAllowThreads();
10960 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10961 wxPyEndAllowThreads(__tstate);
10962 if (PyErr_Occurred()) SWIG_fail;
10963 }
10964 {
10965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10966 }
10967 {
10968 if (temp2)
10969 delete arg2;
10970 }
10971 return resultobj;
10972 fail:
10973 {
10974 if (temp2)
10975 delete arg2;
10976 }
10977 return NULL;
10978 }
10979
10980
10981 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10982 PyObject *resultobj = 0;
10983 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
10984 wxFileSystem *arg2 = 0 ;
10985 wxString *arg3 = 0 ;
10986 wxFSFile *result = 0 ;
10987 void *argp1 = 0 ;
10988 int res1 = 0 ;
10989 void *argp2 = 0 ;
10990 int res2 = 0 ;
10991 bool temp3 = false ;
10992 PyObject * obj0 = 0 ;
10993 PyObject * obj1 = 0 ;
10994 PyObject * obj2 = 0 ;
10995 char * kwnames[] = {
10996 (char *) "self",(char *) "fs",(char *) "location", NULL
10997 };
10998
10999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11001 if (!SWIG_IsOK(res1)) {
11002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11003 }
11004 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11005 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11006 if (!SWIG_IsOK(res2)) {
11007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11008 }
11009 if (!argp2) {
11010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11011 }
11012 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11013 {
11014 arg3 = wxString_in_helper(obj2);
11015 if (arg3 == NULL) SWIG_fail;
11016 temp3 = true;
11017 }
11018 {
11019 PyThreadState* __tstate = wxPyBeginAllowThreads();
11020 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11021 wxPyEndAllowThreads(__tstate);
11022 if (PyErr_Occurred()) SWIG_fail;
11023 }
11024 {
11025 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11026 }
11027 {
11028 if (temp3)
11029 delete arg3;
11030 }
11031 return resultobj;
11032 fail:
11033 {
11034 if (temp3)
11035 delete arg3;
11036 }
11037 return NULL;
11038 }
11039
11040
11041 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11042 PyObject *resultobj = 0;
11043 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11044 wxString *arg2 = 0 ;
11045 int arg3 = (int) 0 ;
11046 wxString result;
11047 void *argp1 = 0 ;
11048 int res1 = 0 ;
11049 bool temp2 = false ;
11050 int val3 ;
11051 int ecode3 = 0 ;
11052 PyObject * obj0 = 0 ;
11053 PyObject * obj1 = 0 ;
11054 PyObject * obj2 = 0 ;
11055 char * kwnames[] = {
11056 (char *) "self",(char *) "spec",(char *) "flags", NULL
11057 };
11058
11059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11061 if (!SWIG_IsOK(res1)) {
11062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11063 }
11064 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11065 {
11066 arg2 = wxString_in_helper(obj1);
11067 if (arg2 == NULL) SWIG_fail;
11068 temp2 = true;
11069 }
11070 if (obj2) {
11071 ecode3 = SWIG_AsVal_int(obj2, &val3);
11072 if (!SWIG_IsOK(ecode3)) {
11073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11074 }
11075 arg3 = static_cast< int >(val3);
11076 }
11077 {
11078 PyThreadState* __tstate = wxPyBeginAllowThreads();
11079 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11080 wxPyEndAllowThreads(__tstate);
11081 if (PyErr_Occurred()) SWIG_fail;
11082 }
11083 {
11084 #if wxUSE_UNICODE
11085 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11086 #else
11087 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11088 #endif
11089 }
11090 {
11091 if (temp2)
11092 delete arg2;
11093 }
11094 return resultobj;
11095 fail:
11096 {
11097 if (temp2)
11098 delete arg2;
11099 }
11100 return NULL;
11101 }
11102
11103
11104 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11105 PyObject *resultobj = 0;
11106 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11107 wxString result;
11108 void *argp1 = 0 ;
11109 int res1 = 0 ;
11110 PyObject *swig_obj[1] ;
11111
11112 if (!args) SWIG_fail;
11113 swig_obj[0] = args;
11114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11115 if (!SWIG_IsOK(res1)) {
11116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11117 }
11118 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11119 {
11120 PyThreadState* __tstate = wxPyBeginAllowThreads();
11121 result = (arg1)->FindNext();
11122 wxPyEndAllowThreads(__tstate);
11123 if (PyErr_Occurred()) SWIG_fail;
11124 }
11125 {
11126 #if wxUSE_UNICODE
11127 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11128 #else
11129 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11130 #endif
11131 }
11132 return resultobj;
11133 fail:
11134 return NULL;
11135 }
11136
11137
11138 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11139 PyObject *obj;
11140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11141 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11142 return SWIG_Py_Void();
11143 }
11144
11145 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11146 return SWIG_Python_InitShadowInstance(args);
11147 }
11148
11149 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11150 PyObject *resultobj = 0;
11151 wxString *arg1 = 0 ;
11152 wxImage *arg2 = 0 ;
11153 long arg3 ;
11154 bool temp1 = false ;
11155 void *argp2 = 0 ;
11156 int res2 = 0 ;
11157 long val3 ;
11158 int ecode3 = 0 ;
11159 PyObject * obj0 = 0 ;
11160 PyObject * obj1 = 0 ;
11161 PyObject * obj2 = 0 ;
11162 char * kwnames[] = {
11163 (char *) "filename",(char *) "image",(char *) "type", NULL
11164 };
11165
11166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11167 {
11168 arg1 = wxString_in_helper(obj0);
11169 if (arg1 == NULL) SWIG_fail;
11170 temp1 = true;
11171 }
11172 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11173 if (!SWIG_IsOK(res2)) {
11174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11175 }
11176 if (!argp2) {
11177 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11178 }
11179 arg2 = reinterpret_cast< wxImage * >(argp2);
11180 ecode3 = SWIG_AsVal_long(obj2, &val3);
11181 if (!SWIG_IsOK(ecode3)) {
11182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11183 }
11184 arg3 = static_cast< long >(val3);
11185 {
11186 PyThreadState* __tstate = wxPyBeginAllowThreads();
11187 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11188 wxPyEndAllowThreads(__tstate);
11189 if (PyErr_Occurred()) SWIG_fail;
11190 }
11191 resultobj = SWIG_Py_Void();
11192 {
11193 if (temp1)
11194 delete arg1;
11195 }
11196 return resultobj;
11197 fail:
11198 {
11199 if (temp1)
11200 delete arg1;
11201 }
11202 return NULL;
11203 }
11204
11205
11206 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11207 PyObject *resultobj = 0;
11208 wxString *arg1 = 0 ;
11209 wxBitmap *arg2 = 0 ;
11210 long arg3 ;
11211 bool temp1 = false ;
11212 void *argp2 = 0 ;
11213 int res2 = 0 ;
11214 long val3 ;
11215 int ecode3 = 0 ;
11216 PyObject * obj0 = 0 ;
11217 PyObject * obj1 = 0 ;
11218 PyObject * obj2 = 0 ;
11219 char * kwnames[] = {
11220 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11221 };
11222
11223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11224 {
11225 arg1 = wxString_in_helper(obj0);
11226 if (arg1 == NULL) SWIG_fail;
11227 temp1 = true;
11228 }
11229 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11230 if (!SWIG_IsOK(res2)) {
11231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11232 }
11233 if (!argp2) {
11234 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11235 }
11236 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11237 ecode3 = SWIG_AsVal_long(obj2, &val3);
11238 if (!SWIG_IsOK(ecode3)) {
11239 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11240 }
11241 arg3 = static_cast< long >(val3);
11242 {
11243 PyThreadState* __tstate = wxPyBeginAllowThreads();
11244 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11245 wxPyEndAllowThreads(__tstate);
11246 if (PyErr_Occurred()) SWIG_fail;
11247 }
11248 resultobj = SWIG_Py_Void();
11249 {
11250 if (temp1)
11251 delete arg1;
11252 }
11253 return resultobj;
11254 fail:
11255 {
11256 if (temp1)
11257 delete arg1;
11258 }
11259 return NULL;
11260 }
11261
11262
11263 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11264 PyObject *resultobj = 0;
11265 wxString *arg1 = 0 ;
11266 PyObject *arg2 = (PyObject *) 0 ;
11267 bool temp1 = false ;
11268 PyObject * obj0 = 0 ;
11269 PyObject * obj1 = 0 ;
11270 char * kwnames[] = {
11271 (char *) "filename",(char *) "data", NULL
11272 };
11273
11274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11275 {
11276 arg1 = wxString_in_helper(obj0);
11277 if (arg1 == NULL) SWIG_fail;
11278 temp1 = true;
11279 }
11280 arg2 = obj1;
11281 {
11282 PyThreadState* __tstate = wxPyBeginAllowThreads();
11283 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11284 wxPyEndAllowThreads(__tstate);
11285 if (PyErr_Occurred()) SWIG_fail;
11286 }
11287 resultobj = SWIG_Py_Void();
11288 {
11289 if (temp1)
11290 delete arg1;
11291 }
11292 return resultobj;
11293 fail:
11294 {
11295 if (temp1)
11296 delete arg1;
11297 }
11298 return NULL;
11299 }
11300
11301
11302 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11303 PyObject *resultobj = 0;
11304 wxMemoryFSHandler *result = 0 ;
11305
11306 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11307 {
11308 PyThreadState* __tstate = wxPyBeginAllowThreads();
11309 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11310 wxPyEndAllowThreads(__tstate);
11311 if (PyErr_Occurred()) SWIG_fail;
11312 }
11313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11314 return resultobj;
11315 fail:
11316 return NULL;
11317 }
11318
11319
11320 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11321 PyObject *resultobj = 0;
11322 wxString *arg1 = 0 ;
11323 bool temp1 = false ;
11324 PyObject * obj0 = 0 ;
11325 char * kwnames[] = {
11326 (char *) "filename", NULL
11327 };
11328
11329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11330 {
11331 arg1 = wxString_in_helper(obj0);
11332 if (arg1 == NULL) SWIG_fail;
11333 temp1 = true;
11334 }
11335 {
11336 PyThreadState* __tstate = wxPyBeginAllowThreads();
11337 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11338 wxPyEndAllowThreads(__tstate);
11339 if (PyErr_Occurred()) SWIG_fail;
11340 }
11341 resultobj = SWIG_Py_Void();
11342 {
11343 if (temp1)
11344 delete arg1;
11345 }
11346 return resultobj;
11347 fail:
11348 {
11349 if (temp1)
11350 delete arg1;
11351 }
11352 return NULL;
11353 }
11354
11355
11356 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11357 PyObject *resultobj = 0;
11358 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11359 wxString *arg2 = 0 ;
11360 bool result;
11361 void *argp1 = 0 ;
11362 int res1 = 0 ;
11363 bool temp2 = false ;
11364 PyObject * obj0 = 0 ;
11365 PyObject * obj1 = 0 ;
11366 char * kwnames[] = {
11367 (char *) "self",(char *) "location", NULL
11368 };
11369
11370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11372 if (!SWIG_IsOK(res1)) {
11373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11374 }
11375 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11376 {
11377 arg2 = wxString_in_helper(obj1);
11378 if (arg2 == NULL) SWIG_fail;
11379 temp2 = true;
11380 }
11381 {
11382 PyThreadState* __tstate = wxPyBeginAllowThreads();
11383 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11384 wxPyEndAllowThreads(__tstate);
11385 if (PyErr_Occurred()) SWIG_fail;
11386 }
11387 {
11388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11389 }
11390 {
11391 if (temp2)
11392 delete arg2;
11393 }
11394 return resultobj;
11395 fail:
11396 {
11397 if (temp2)
11398 delete arg2;
11399 }
11400 return NULL;
11401 }
11402
11403
11404 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11405 PyObject *resultobj = 0;
11406 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11407 wxFileSystem *arg2 = 0 ;
11408 wxString *arg3 = 0 ;
11409 wxFSFile *result = 0 ;
11410 void *argp1 = 0 ;
11411 int res1 = 0 ;
11412 void *argp2 = 0 ;
11413 int res2 = 0 ;
11414 bool temp3 = false ;
11415 PyObject * obj0 = 0 ;
11416 PyObject * obj1 = 0 ;
11417 PyObject * obj2 = 0 ;
11418 char * kwnames[] = {
11419 (char *) "self",(char *) "fs",(char *) "location", NULL
11420 };
11421
11422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11424 if (!SWIG_IsOK(res1)) {
11425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11426 }
11427 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11428 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11429 if (!SWIG_IsOK(res2)) {
11430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11431 }
11432 if (!argp2) {
11433 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11434 }
11435 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11436 {
11437 arg3 = wxString_in_helper(obj2);
11438 if (arg3 == NULL) SWIG_fail;
11439 temp3 = true;
11440 }
11441 {
11442 PyThreadState* __tstate = wxPyBeginAllowThreads();
11443 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11444 wxPyEndAllowThreads(__tstate);
11445 if (PyErr_Occurred()) SWIG_fail;
11446 }
11447 {
11448 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11449 }
11450 {
11451 if (temp3)
11452 delete arg3;
11453 }
11454 return resultobj;
11455 fail:
11456 {
11457 if (temp3)
11458 delete arg3;
11459 }
11460 return NULL;
11461 }
11462
11463
11464 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11465 PyObject *resultobj = 0;
11466 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11467 wxString *arg2 = 0 ;
11468 int arg3 = (int) 0 ;
11469 wxString result;
11470 void *argp1 = 0 ;
11471 int res1 = 0 ;
11472 bool temp2 = false ;
11473 int val3 ;
11474 int ecode3 = 0 ;
11475 PyObject * obj0 = 0 ;
11476 PyObject * obj1 = 0 ;
11477 PyObject * obj2 = 0 ;
11478 char * kwnames[] = {
11479 (char *) "self",(char *) "spec",(char *) "flags", NULL
11480 };
11481
11482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11484 if (!SWIG_IsOK(res1)) {
11485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11486 }
11487 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11488 {
11489 arg2 = wxString_in_helper(obj1);
11490 if (arg2 == NULL) SWIG_fail;
11491 temp2 = true;
11492 }
11493 if (obj2) {
11494 ecode3 = SWIG_AsVal_int(obj2, &val3);
11495 if (!SWIG_IsOK(ecode3)) {
11496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11497 }
11498 arg3 = static_cast< int >(val3);
11499 }
11500 {
11501 PyThreadState* __tstate = wxPyBeginAllowThreads();
11502 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11503 wxPyEndAllowThreads(__tstate);
11504 if (PyErr_Occurred()) SWIG_fail;
11505 }
11506 {
11507 #if wxUSE_UNICODE
11508 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11509 #else
11510 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11511 #endif
11512 }
11513 {
11514 if (temp2)
11515 delete arg2;
11516 }
11517 return resultobj;
11518 fail:
11519 {
11520 if (temp2)
11521 delete arg2;
11522 }
11523 return NULL;
11524 }
11525
11526
11527 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11528 PyObject *resultobj = 0;
11529 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11530 wxString result;
11531 void *argp1 = 0 ;
11532 int res1 = 0 ;
11533 PyObject *swig_obj[1] ;
11534
11535 if (!args) SWIG_fail;
11536 swig_obj[0] = args;
11537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11538 if (!SWIG_IsOK(res1)) {
11539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11540 }
11541 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11542 {
11543 PyThreadState* __tstate = wxPyBeginAllowThreads();
11544 result = (arg1)->FindNext();
11545 wxPyEndAllowThreads(__tstate);
11546 if (PyErr_Occurred()) SWIG_fail;
11547 }
11548 {
11549 #if wxUSE_UNICODE
11550 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11551 #else
11552 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11553 #endif
11554 }
11555 return resultobj;
11556 fail:
11557 return NULL;
11558 }
11559
11560
11561 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11562 PyObject *obj;
11563 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11564 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11565 return SWIG_Py_Void();
11566 }
11567
11568 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11569 return SWIG_Python_InitShadowInstance(args);
11570 }
11571
11572 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11573 PyObject *resultobj = 0;
11574 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11575 wxString result;
11576 void *argp1 = 0 ;
11577 int res1 = 0 ;
11578 PyObject *swig_obj[1] ;
11579
11580 if (!args) SWIG_fail;
11581 swig_obj[0] = args;
11582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11583 if (!SWIG_IsOK(res1)) {
11584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11585 }
11586 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11587 {
11588 PyThreadState* __tstate = wxPyBeginAllowThreads();
11589 result = (arg1)->GetName();
11590 wxPyEndAllowThreads(__tstate);
11591 if (PyErr_Occurred()) SWIG_fail;
11592 }
11593 {
11594 #if wxUSE_UNICODE
11595 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11596 #else
11597 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11598 #endif
11599 }
11600 return resultobj;
11601 fail:
11602 return NULL;
11603 }
11604
11605
11606 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11607 PyObject *resultobj = 0;
11608 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11609 wxString result;
11610 void *argp1 = 0 ;
11611 int res1 = 0 ;
11612 PyObject *swig_obj[1] ;
11613
11614 if (!args) SWIG_fail;
11615 swig_obj[0] = args;
11616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11617 if (!SWIG_IsOK(res1)) {
11618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11619 }
11620 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11621 {
11622 PyThreadState* __tstate = wxPyBeginAllowThreads();
11623 result = (arg1)->GetExtension();
11624 wxPyEndAllowThreads(__tstate);
11625 if (PyErr_Occurred()) SWIG_fail;
11626 }
11627 {
11628 #if wxUSE_UNICODE
11629 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11630 #else
11631 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11632 #endif
11633 }
11634 return resultobj;
11635 fail:
11636 return NULL;
11637 }
11638
11639
11640 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11641 PyObject *resultobj = 0;
11642 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11643 long result;
11644 void *argp1 = 0 ;
11645 int res1 = 0 ;
11646 PyObject *swig_obj[1] ;
11647
11648 if (!args) SWIG_fail;
11649 swig_obj[0] = args;
11650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11651 if (!SWIG_IsOK(res1)) {
11652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11653 }
11654 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11655 {
11656 PyThreadState* __tstate = wxPyBeginAllowThreads();
11657 result = (long)(arg1)->GetType();
11658 wxPyEndAllowThreads(__tstate);
11659 if (PyErr_Occurred()) SWIG_fail;
11660 }
11661 resultobj = SWIG_From_long(static_cast< long >(result));
11662 return resultobj;
11663 fail:
11664 return NULL;
11665 }
11666
11667
11668 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11669 PyObject *resultobj = 0;
11670 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11671 wxString result;
11672 void *argp1 = 0 ;
11673 int res1 = 0 ;
11674 PyObject *swig_obj[1] ;
11675
11676 if (!args) SWIG_fail;
11677 swig_obj[0] = args;
11678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11679 if (!SWIG_IsOK(res1)) {
11680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11681 }
11682 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11683 {
11684 PyThreadState* __tstate = wxPyBeginAllowThreads();
11685 result = (arg1)->GetMimeType();
11686 wxPyEndAllowThreads(__tstate);
11687 if (PyErr_Occurred()) SWIG_fail;
11688 }
11689 {
11690 #if wxUSE_UNICODE
11691 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11692 #else
11693 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11694 #endif
11695 }
11696 return resultobj;
11697 fail:
11698 return NULL;
11699 }
11700
11701
11702 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11703 PyObject *resultobj = 0;
11704 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11705 wxString *arg2 = 0 ;
11706 bool result;
11707 void *argp1 = 0 ;
11708 int res1 = 0 ;
11709 bool temp2 = false ;
11710 PyObject * obj0 = 0 ;
11711 PyObject * obj1 = 0 ;
11712 char * kwnames[] = {
11713 (char *) "self",(char *) "name", NULL
11714 };
11715
11716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11718 if (!SWIG_IsOK(res1)) {
11719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11720 }
11721 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11722 {
11723 arg2 = wxString_in_helper(obj1);
11724 if (arg2 == NULL) SWIG_fail;
11725 temp2 = true;
11726 }
11727 {
11728 PyThreadState* __tstate = wxPyBeginAllowThreads();
11729 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11730 wxPyEndAllowThreads(__tstate);
11731 if (PyErr_Occurred()) SWIG_fail;
11732 }
11733 {
11734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11735 }
11736 {
11737 if (temp2)
11738 delete arg2;
11739 }
11740 return resultobj;
11741 fail:
11742 {
11743 if (temp2)
11744 delete arg2;
11745 }
11746 return NULL;
11747 }
11748
11749
11750 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11751 PyObject *resultobj = 0;
11752 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11753 wxString *arg2 = 0 ;
11754 void *argp1 = 0 ;
11755 int res1 = 0 ;
11756 bool temp2 = false ;
11757 PyObject * obj0 = 0 ;
11758 PyObject * obj1 = 0 ;
11759 char * kwnames[] = {
11760 (char *) "self",(char *) "name", NULL
11761 };
11762
11763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11765 if (!SWIG_IsOK(res1)) {
11766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11767 }
11768 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11769 {
11770 arg2 = wxString_in_helper(obj1);
11771 if (arg2 == NULL) SWIG_fail;
11772 temp2 = true;
11773 }
11774 {
11775 PyThreadState* __tstate = wxPyBeginAllowThreads();
11776 (arg1)->SetName((wxString const &)*arg2);
11777 wxPyEndAllowThreads(__tstate);
11778 if (PyErr_Occurred()) SWIG_fail;
11779 }
11780 resultobj = SWIG_Py_Void();
11781 {
11782 if (temp2)
11783 delete arg2;
11784 }
11785 return resultobj;
11786 fail:
11787 {
11788 if (temp2)
11789 delete arg2;
11790 }
11791 return NULL;
11792 }
11793
11794
11795 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11796 PyObject *resultobj = 0;
11797 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11798 wxString *arg2 = 0 ;
11799 void *argp1 = 0 ;
11800 int res1 = 0 ;
11801 bool temp2 = false ;
11802 PyObject * obj0 = 0 ;
11803 PyObject * obj1 = 0 ;
11804 char * kwnames[] = {
11805 (char *) "self",(char *) "extension", NULL
11806 };
11807
11808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11810 if (!SWIG_IsOK(res1)) {
11811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11812 }
11813 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11814 {
11815 arg2 = wxString_in_helper(obj1);
11816 if (arg2 == NULL) SWIG_fail;
11817 temp2 = true;
11818 }
11819 {
11820 PyThreadState* __tstate = wxPyBeginAllowThreads();
11821 (arg1)->SetExtension((wxString const &)*arg2);
11822 wxPyEndAllowThreads(__tstate);
11823 if (PyErr_Occurred()) SWIG_fail;
11824 }
11825 resultobj = SWIG_Py_Void();
11826 {
11827 if (temp2)
11828 delete arg2;
11829 }
11830 return resultobj;
11831 fail:
11832 {
11833 if (temp2)
11834 delete arg2;
11835 }
11836 return NULL;
11837 }
11838
11839
11840 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11841 PyObject *resultobj = 0;
11842 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11843 long arg2 ;
11844 void *argp1 = 0 ;
11845 int res1 = 0 ;
11846 long val2 ;
11847 int ecode2 = 0 ;
11848 PyObject * obj0 = 0 ;
11849 PyObject * obj1 = 0 ;
11850 char * kwnames[] = {
11851 (char *) "self",(char *) "type", NULL
11852 };
11853
11854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11856 if (!SWIG_IsOK(res1)) {
11857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11858 }
11859 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11860 ecode2 = SWIG_AsVal_long(obj1, &val2);
11861 if (!SWIG_IsOK(ecode2)) {
11862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11863 }
11864 arg2 = static_cast< long >(val2);
11865 {
11866 PyThreadState* __tstate = wxPyBeginAllowThreads();
11867 (arg1)->SetType(arg2);
11868 wxPyEndAllowThreads(__tstate);
11869 if (PyErr_Occurred()) SWIG_fail;
11870 }
11871 resultobj = SWIG_Py_Void();
11872 return resultobj;
11873 fail:
11874 return NULL;
11875 }
11876
11877
11878 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11879 PyObject *resultobj = 0;
11880 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11881 wxString *arg2 = 0 ;
11882 void *argp1 = 0 ;
11883 int res1 = 0 ;
11884 bool temp2 = false ;
11885 PyObject * obj0 = 0 ;
11886 PyObject * obj1 = 0 ;
11887 char * kwnames[] = {
11888 (char *) "self",(char *) "mimetype", NULL
11889 };
11890
11891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11893 if (!SWIG_IsOK(res1)) {
11894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11895 }
11896 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11897 {
11898 arg2 = wxString_in_helper(obj1);
11899 if (arg2 == NULL) SWIG_fail;
11900 temp2 = true;
11901 }
11902 {
11903 PyThreadState* __tstate = wxPyBeginAllowThreads();
11904 (arg1)->SetMimeType((wxString const &)*arg2);
11905 wxPyEndAllowThreads(__tstate);
11906 if (PyErr_Occurred()) SWIG_fail;
11907 }
11908 resultobj = SWIG_Py_Void();
11909 {
11910 if (temp2)
11911 delete arg2;
11912 }
11913 return resultobj;
11914 fail:
11915 {
11916 if (temp2)
11917 delete arg2;
11918 }
11919 return NULL;
11920 }
11921
11922
11923 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11924 PyObject *obj;
11925 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11926 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
11927 return SWIG_Py_Void();
11928 }
11929
11930 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11931 PyObject *resultobj = 0;
11932 wxPyImageHandler *result = 0 ;
11933
11934 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
11935 {
11936 PyThreadState* __tstate = wxPyBeginAllowThreads();
11937 result = (wxPyImageHandler *)new wxPyImageHandler();
11938 wxPyEndAllowThreads(__tstate);
11939 if (PyErr_Occurred()) SWIG_fail;
11940 }
11941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
11942 return resultobj;
11943 fail:
11944 return NULL;
11945 }
11946
11947
11948 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11949 PyObject *resultobj = 0;
11950 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
11951 PyObject *arg2 = (PyObject *) 0 ;
11952 void *argp1 = 0 ;
11953 int res1 = 0 ;
11954 PyObject * obj0 = 0 ;
11955 PyObject * obj1 = 0 ;
11956 char * kwnames[] = {
11957 (char *) "self",(char *) "self", NULL
11958 };
11959
11960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
11961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
11962 if (!SWIG_IsOK(res1)) {
11963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
11964 }
11965 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
11966 arg2 = obj1;
11967 {
11968 PyThreadState* __tstate = wxPyBeginAllowThreads();
11969 (arg1)->_SetSelf(arg2);
11970 wxPyEndAllowThreads(__tstate);
11971 if (PyErr_Occurred()) SWIG_fail;
11972 }
11973 resultobj = SWIG_Py_Void();
11974 return resultobj;
11975 fail:
11976 return NULL;
11977 }
11978
11979
11980 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11981 PyObject *obj;
11982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11983 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
11984 return SWIG_Py_Void();
11985 }
11986
11987 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11988 return SWIG_Python_InitShadowInstance(args);
11989 }
11990
11991 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11992 PyObject *resultobj = 0;
11993 wxImageHistogram *result = 0 ;
11994
11995 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
11996 {
11997 PyThreadState* __tstate = wxPyBeginAllowThreads();
11998 result = (wxImageHistogram *)new wxImageHistogram();
11999 wxPyEndAllowThreads(__tstate);
12000 if (PyErr_Occurred()) SWIG_fail;
12001 }
12002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12003 return resultobj;
12004 fail:
12005 return NULL;
12006 }
12007
12008
12009 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12010 PyObject *resultobj = 0;
12011 byte arg1 ;
12012 byte arg2 ;
12013 byte arg3 ;
12014 unsigned long result;
12015 unsigned char val1 ;
12016 int ecode1 = 0 ;
12017 unsigned char val2 ;
12018 int ecode2 = 0 ;
12019 unsigned char val3 ;
12020 int ecode3 = 0 ;
12021 PyObject * obj0 = 0 ;
12022 PyObject * obj1 = 0 ;
12023 PyObject * obj2 = 0 ;
12024 char * kwnames[] = {
12025 (char *) "r",(char *) "g",(char *) "b", NULL
12026 };
12027
12028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12029 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12030 if (!SWIG_IsOK(ecode1)) {
12031 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12032 }
12033 arg1 = static_cast< byte >(val1);
12034 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12035 if (!SWIG_IsOK(ecode2)) {
12036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12037 }
12038 arg2 = static_cast< byte >(val2);
12039 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12040 if (!SWIG_IsOK(ecode3)) {
12041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12042 }
12043 arg3 = static_cast< byte >(val3);
12044 {
12045 PyThreadState* __tstate = wxPyBeginAllowThreads();
12046 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12047 wxPyEndAllowThreads(__tstate);
12048 if (PyErr_Occurred()) SWIG_fail;
12049 }
12050 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12051 return resultobj;
12052 fail:
12053 return NULL;
12054 }
12055
12056
12057 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12058 PyObject *resultobj = 0;
12059 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12060 byte *arg2 = (byte *) 0 ;
12061 byte *arg3 = (byte *) 0 ;
12062 byte *arg4 = (byte *) 0 ;
12063 byte arg5 = (byte) 1 ;
12064 byte arg6 = (byte) 0 ;
12065 byte arg7 = (byte) 0 ;
12066 bool result;
12067 void *argp1 = 0 ;
12068 int res1 = 0 ;
12069 byte temp2 ;
12070 int res2 = SWIG_TMPOBJ ;
12071 byte temp3 ;
12072 int res3 = SWIG_TMPOBJ ;
12073 byte temp4 ;
12074 int res4 = SWIG_TMPOBJ ;
12075 unsigned char val5 ;
12076 int ecode5 = 0 ;
12077 unsigned char val6 ;
12078 int ecode6 = 0 ;
12079 unsigned char val7 ;
12080 int ecode7 = 0 ;
12081 PyObject * obj0 = 0 ;
12082 PyObject * obj1 = 0 ;
12083 PyObject * obj2 = 0 ;
12084 PyObject * obj3 = 0 ;
12085 char * kwnames[] = {
12086 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12087 };
12088
12089 arg2 = &temp2;
12090 arg3 = &temp3;
12091 arg4 = &temp4;
12092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12094 if (!SWIG_IsOK(res1)) {
12095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12096 }
12097 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12098 if (obj1) {
12099 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12100 if (!SWIG_IsOK(ecode5)) {
12101 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12102 }
12103 arg5 = static_cast< byte >(val5);
12104 }
12105 if (obj2) {
12106 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12107 if (!SWIG_IsOK(ecode6)) {
12108 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12109 }
12110 arg6 = static_cast< byte >(val6);
12111 }
12112 if (obj3) {
12113 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12114 if (!SWIG_IsOK(ecode7)) {
12115 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12116 }
12117 arg7 = static_cast< byte >(val7);
12118 }
12119 {
12120 PyThreadState* __tstate = wxPyBeginAllowThreads();
12121 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12122 wxPyEndAllowThreads(__tstate);
12123 if (PyErr_Occurred()) SWIG_fail;
12124 }
12125 {
12126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12127 }
12128 if (SWIG_IsTmpObj(res2)) {
12129 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12130 } else {
12131 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12132 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12133 }
12134 if (SWIG_IsTmpObj(res3)) {
12135 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12136 } else {
12137 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12139 }
12140 if (SWIG_IsTmpObj(res4)) {
12141 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12142 } else {
12143 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12145 }
12146 return resultobj;
12147 fail:
12148 return NULL;
12149 }
12150
12151
12152 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12153 PyObject *resultobj = 0;
12154 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12155 unsigned long arg2 ;
12156 unsigned long result;
12157 void *argp1 = 0 ;
12158 int res1 = 0 ;
12159 unsigned long val2 ;
12160 int ecode2 = 0 ;
12161 PyObject * obj0 = 0 ;
12162 PyObject * obj1 = 0 ;
12163 char * kwnames[] = {
12164 (char *) "self",(char *) "key", NULL
12165 };
12166
12167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12169 if (!SWIG_IsOK(res1)) {
12170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12171 }
12172 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12173 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12174 if (!SWIG_IsOK(ecode2)) {
12175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12176 }
12177 arg2 = static_cast< unsigned long >(val2);
12178 {
12179 PyThreadState* __tstate = wxPyBeginAllowThreads();
12180 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12181 wxPyEndAllowThreads(__tstate);
12182 if (PyErr_Occurred()) SWIG_fail;
12183 }
12184 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12185 return resultobj;
12186 fail:
12187 return NULL;
12188 }
12189
12190
12191 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12192 PyObject *resultobj = 0;
12193 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12194 byte arg2 ;
12195 byte arg3 ;
12196 byte arg4 ;
12197 unsigned long result;
12198 void *argp1 = 0 ;
12199 int res1 = 0 ;
12200 unsigned char val2 ;
12201 int ecode2 = 0 ;
12202 unsigned char val3 ;
12203 int ecode3 = 0 ;
12204 unsigned char val4 ;
12205 int ecode4 = 0 ;
12206 PyObject * obj0 = 0 ;
12207 PyObject * obj1 = 0 ;
12208 PyObject * obj2 = 0 ;
12209 PyObject * obj3 = 0 ;
12210 char * kwnames[] = {
12211 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12212 };
12213
12214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12216 if (!SWIG_IsOK(res1)) {
12217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12218 }
12219 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12220 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12221 if (!SWIG_IsOK(ecode2)) {
12222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12223 }
12224 arg2 = static_cast< byte >(val2);
12225 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12226 if (!SWIG_IsOK(ecode3)) {
12227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12228 }
12229 arg3 = static_cast< byte >(val3);
12230 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12231 if (!SWIG_IsOK(ecode4)) {
12232 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12233 }
12234 arg4 = static_cast< byte >(val4);
12235 {
12236 PyThreadState* __tstate = wxPyBeginAllowThreads();
12237 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12238 wxPyEndAllowThreads(__tstate);
12239 if (PyErr_Occurred()) SWIG_fail;
12240 }
12241 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12242 return resultobj;
12243 fail:
12244 return NULL;
12245 }
12246
12247
12248 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12249 PyObject *resultobj = 0;
12250 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12251 wxColour *arg2 = 0 ;
12252 unsigned long result;
12253 void *argp1 = 0 ;
12254 int res1 = 0 ;
12255 wxColour temp2 ;
12256 PyObject * obj0 = 0 ;
12257 PyObject * obj1 = 0 ;
12258 char * kwnames[] = {
12259 (char *) "self",(char *) "colour", NULL
12260 };
12261
12262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) 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_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12266 }
12267 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12268 {
12269 arg2 = &temp2;
12270 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12271 }
12272 {
12273 PyThreadState* __tstate = wxPyBeginAllowThreads();
12274 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12275 wxPyEndAllowThreads(__tstate);
12276 if (PyErr_Occurred()) SWIG_fail;
12277 }
12278 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12279 return resultobj;
12280 fail:
12281 return NULL;
12282 }
12283
12284
12285 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12286 PyObject *obj;
12287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12288 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12289 return SWIG_Py_Void();
12290 }
12291
12292 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12293 return SWIG_Python_InitShadowInstance(args);
12294 }
12295
12296 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12297 PyObject *resultobj = 0;
12298 byte arg1 = (byte) 0 ;
12299 byte arg2 = (byte) 0 ;
12300 byte arg3 = (byte) 0 ;
12301 wxImage_RGBValue *result = 0 ;
12302 unsigned char val1 ;
12303 int ecode1 = 0 ;
12304 unsigned char val2 ;
12305 int ecode2 = 0 ;
12306 unsigned char val3 ;
12307 int ecode3 = 0 ;
12308 PyObject * obj0 = 0 ;
12309 PyObject * obj1 = 0 ;
12310 PyObject * obj2 = 0 ;
12311 char * kwnames[] = {
12312 (char *) "r",(char *) "g",(char *) "b", NULL
12313 };
12314
12315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12316 if (obj0) {
12317 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12318 if (!SWIG_IsOK(ecode1)) {
12319 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12320 }
12321 arg1 = static_cast< byte >(val1);
12322 }
12323 if (obj1) {
12324 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12325 if (!SWIG_IsOK(ecode2)) {
12326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12327 }
12328 arg2 = static_cast< byte >(val2);
12329 }
12330 if (obj2) {
12331 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12332 if (!SWIG_IsOK(ecode3)) {
12333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12334 }
12335 arg3 = static_cast< byte >(val3);
12336 }
12337 {
12338 PyThreadState* __tstate = wxPyBeginAllowThreads();
12339 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12340 wxPyEndAllowThreads(__tstate);
12341 if (PyErr_Occurred()) SWIG_fail;
12342 }
12343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12344 return resultobj;
12345 fail:
12346 return NULL;
12347 }
12348
12349
12350 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12351 PyObject *resultobj = 0;
12352 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12353 byte arg2 ;
12354 void *argp1 = 0 ;
12355 int res1 = 0 ;
12356 unsigned char val2 ;
12357 int ecode2 = 0 ;
12358 PyObject *swig_obj[2] ;
12359
12360 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12362 if (!SWIG_IsOK(res1)) {
12363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12364 }
12365 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12366 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12367 if (!SWIG_IsOK(ecode2)) {
12368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12369 }
12370 arg2 = static_cast< byte >(val2);
12371 if (arg1) (arg1)->red = arg2;
12372
12373 resultobj = SWIG_Py_Void();
12374 return resultobj;
12375 fail:
12376 return NULL;
12377 }
12378
12379
12380 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12381 PyObject *resultobj = 0;
12382 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12383 byte result;
12384 void *argp1 = 0 ;
12385 int res1 = 0 ;
12386 PyObject *swig_obj[1] ;
12387
12388 if (!args) SWIG_fail;
12389 swig_obj[0] = args;
12390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12391 if (!SWIG_IsOK(res1)) {
12392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12393 }
12394 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12395 result = (byte) ((arg1)->red);
12396 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12397 return resultobj;
12398 fail:
12399 return NULL;
12400 }
12401
12402
12403 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12404 PyObject *resultobj = 0;
12405 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12406 byte arg2 ;
12407 void *argp1 = 0 ;
12408 int res1 = 0 ;
12409 unsigned char val2 ;
12410 int ecode2 = 0 ;
12411 PyObject *swig_obj[2] ;
12412
12413 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12415 if (!SWIG_IsOK(res1)) {
12416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12417 }
12418 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12419 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12420 if (!SWIG_IsOK(ecode2)) {
12421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12422 }
12423 arg2 = static_cast< byte >(val2);
12424 if (arg1) (arg1)->green = arg2;
12425
12426 resultobj = SWIG_Py_Void();
12427 return resultobj;
12428 fail:
12429 return NULL;
12430 }
12431
12432
12433 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12434 PyObject *resultobj = 0;
12435 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12436 byte result;
12437 void *argp1 = 0 ;
12438 int res1 = 0 ;
12439 PyObject *swig_obj[1] ;
12440
12441 if (!args) SWIG_fail;
12442 swig_obj[0] = args;
12443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12444 if (!SWIG_IsOK(res1)) {
12445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12446 }
12447 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12448 result = (byte) ((arg1)->green);
12449 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12450 return resultobj;
12451 fail:
12452 return NULL;
12453 }
12454
12455
12456 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12457 PyObject *resultobj = 0;
12458 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12459 byte arg2 ;
12460 void *argp1 = 0 ;
12461 int res1 = 0 ;
12462 unsigned char val2 ;
12463 int ecode2 = 0 ;
12464 PyObject *swig_obj[2] ;
12465
12466 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12468 if (!SWIG_IsOK(res1)) {
12469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12470 }
12471 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12472 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12473 if (!SWIG_IsOK(ecode2)) {
12474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12475 }
12476 arg2 = static_cast< byte >(val2);
12477 if (arg1) (arg1)->blue = arg2;
12478
12479 resultobj = SWIG_Py_Void();
12480 return resultobj;
12481 fail:
12482 return NULL;
12483 }
12484
12485
12486 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12487 PyObject *resultobj = 0;
12488 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12489 byte result;
12490 void *argp1 = 0 ;
12491 int res1 = 0 ;
12492 PyObject *swig_obj[1] ;
12493
12494 if (!args) SWIG_fail;
12495 swig_obj[0] = args;
12496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12497 if (!SWIG_IsOK(res1)) {
12498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12499 }
12500 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12501 result = (byte) ((arg1)->blue);
12502 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12503 return resultobj;
12504 fail:
12505 return NULL;
12506 }
12507
12508
12509 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12510 PyObject *obj;
12511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12512 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12513 return SWIG_Py_Void();
12514 }
12515
12516 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12517 return SWIG_Python_InitShadowInstance(args);
12518 }
12519
12520 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12521 PyObject *resultobj = 0;
12522 double arg1 = (double) 0.0 ;
12523 double arg2 = (double) 0.0 ;
12524 double arg3 = (double) 0.0 ;
12525 wxImage_HSVValue *result = 0 ;
12526 double val1 ;
12527 int ecode1 = 0 ;
12528 double val2 ;
12529 int ecode2 = 0 ;
12530 double val3 ;
12531 int ecode3 = 0 ;
12532 PyObject * obj0 = 0 ;
12533 PyObject * obj1 = 0 ;
12534 PyObject * obj2 = 0 ;
12535 char * kwnames[] = {
12536 (char *) "h",(char *) "s",(char *) "v", NULL
12537 };
12538
12539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12540 if (obj0) {
12541 ecode1 = SWIG_AsVal_double(obj0, &val1);
12542 if (!SWIG_IsOK(ecode1)) {
12543 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12544 }
12545 arg1 = static_cast< double >(val1);
12546 }
12547 if (obj1) {
12548 ecode2 = SWIG_AsVal_double(obj1, &val2);
12549 if (!SWIG_IsOK(ecode2)) {
12550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12551 }
12552 arg2 = static_cast< double >(val2);
12553 }
12554 if (obj2) {
12555 ecode3 = SWIG_AsVal_double(obj2, &val3);
12556 if (!SWIG_IsOK(ecode3)) {
12557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12558 }
12559 arg3 = static_cast< double >(val3);
12560 }
12561 {
12562 PyThreadState* __tstate = wxPyBeginAllowThreads();
12563 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12564 wxPyEndAllowThreads(__tstate);
12565 if (PyErr_Occurred()) SWIG_fail;
12566 }
12567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12568 return resultobj;
12569 fail:
12570 return NULL;
12571 }
12572
12573
12574 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12575 PyObject *resultobj = 0;
12576 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12577 double arg2 ;
12578 void *argp1 = 0 ;
12579 int res1 = 0 ;
12580 double val2 ;
12581 int ecode2 = 0 ;
12582 PyObject *swig_obj[2] ;
12583
12584 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12586 if (!SWIG_IsOK(res1)) {
12587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12588 }
12589 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12590 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12591 if (!SWIG_IsOK(ecode2)) {
12592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12593 }
12594 arg2 = static_cast< double >(val2);
12595 if (arg1) (arg1)->hue = arg2;
12596
12597 resultobj = SWIG_Py_Void();
12598 return resultobj;
12599 fail:
12600 return NULL;
12601 }
12602
12603
12604 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12605 PyObject *resultobj = 0;
12606 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12607 double result;
12608 void *argp1 = 0 ;
12609 int res1 = 0 ;
12610 PyObject *swig_obj[1] ;
12611
12612 if (!args) SWIG_fail;
12613 swig_obj[0] = args;
12614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12615 if (!SWIG_IsOK(res1)) {
12616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12617 }
12618 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12619 result = (double) ((arg1)->hue);
12620 resultobj = SWIG_From_double(static_cast< double >(result));
12621 return resultobj;
12622 fail:
12623 return NULL;
12624 }
12625
12626
12627 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12628 PyObject *resultobj = 0;
12629 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12630 double arg2 ;
12631 void *argp1 = 0 ;
12632 int res1 = 0 ;
12633 double val2 ;
12634 int ecode2 = 0 ;
12635 PyObject *swig_obj[2] ;
12636
12637 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12639 if (!SWIG_IsOK(res1)) {
12640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12641 }
12642 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12643 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12644 if (!SWIG_IsOK(ecode2)) {
12645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12646 }
12647 arg2 = static_cast< double >(val2);
12648 if (arg1) (arg1)->saturation = arg2;
12649
12650 resultobj = SWIG_Py_Void();
12651 return resultobj;
12652 fail:
12653 return NULL;
12654 }
12655
12656
12657 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12658 PyObject *resultobj = 0;
12659 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12660 double result;
12661 void *argp1 = 0 ;
12662 int res1 = 0 ;
12663 PyObject *swig_obj[1] ;
12664
12665 if (!args) SWIG_fail;
12666 swig_obj[0] = args;
12667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12668 if (!SWIG_IsOK(res1)) {
12669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12670 }
12671 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12672 result = (double) ((arg1)->saturation);
12673 resultobj = SWIG_From_double(static_cast< double >(result));
12674 return resultobj;
12675 fail:
12676 return NULL;
12677 }
12678
12679
12680 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12681 PyObject *resultobj = 0;
12682 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12683 double arg2 ;
12684 void *argp1 = 0 ;
12685 int res1 = 0 ;
12686 double val2 ;
12687 int ecode2 = 0 ;
12688 PyObject *swig_obj[2] ;
12689
12690 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12692 if (!SWIG_IsOK(res1)) {
12693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12694 }
12695 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12696 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12697 if (!SWIG_IsOK(ecode2)) {
12698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12699 }
12700 arg2 = static_cast< double >(val2);
12701 if (arg1) (arg1)->value = arg2;
12702
12703 resultobj = SWIG_Py_Void();
12704 return resultobj;
12705 fail:
12706 return NULL;
12707 }
12708
12709
12710 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12711 PyObject *resultobj = 0;
12712 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12713 double result;
12714 void *argp1 = 0 ;
12715 int res1 = 0 ;
12716 PyObject *swig_obj[1] ;
12717
12718 if (!args) SWIG_fail;
12719 swig_obj[0] = args;
12720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12721 if (!SWIG_IsOK(res1)) {
12722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12723 }
12724 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12725 result = (double) ((arg1)->value);
12726 resultobj = SWIG_From_double(static_cast< double >(result));
12727 return resultobj;
12728 fail:
12729 return NULL;
12730 }
12731
12732
12733 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12734 PyObject *obj;
12735 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12736 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12737 return SWIG_Py_Void();
12738 }
12739
12740 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12741 return SWIG_Python_InitShadowInstance(args);
12742 }
12743
12744 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12745 PyObject *resultobj = 0;
12746 wxString *arg1 = 0 ;
12747 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12748 int arg3 = (int) -1 ;
12749 wxImage *result = 0 ;
12750 bool temp1 = false ;
12751 long val2 ;
12752 int ecode2 = 0 ;
12753 int val3 ;
12754 int ecode3 = 0 ;
12755 PyObject * obj0 = 0 ;
12756 PyObject * obj1 = 0 ;
12757 PyObject * obj2 = 0 ;
12758 char * kwnames[] = {
12759 (char *) "name",(char *) "type",(char *) "index", NULL
12760 };
12761
12762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12763 {
12764 arg1 = wxString_in_helper(obj0);
12765 if (arg1 == NULL) SWIG_fail;
12766 temp1 = true;
12767 }
12768 if (obj1) {
12769 ecode2 = SWIG_AsVal_long(obj1, &val2);
12770 if (!SWIG_IsOK(ecode2)) {
12771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12772 }
12773 arg2 = static_cast< long >(val2);
12774 }
12775 if (obj2) {
12776 ecode3 = SWIG_AsVal_int(obj2, &val3);
12777 if (!SWIG_IsOK(ecode3)) {
12778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12779 }
12780 arg3 = static_cast< int >(val3);
12781 }
12782 {
12783 PyThreadState* __tstate = wxPyBeginAllowThreads();
12784 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12785 wxPyEndAllowThreads(__tstate);
12786 if (PyErr_Occurred()) SWIG_fail;
12787 }
12788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12789 {
12790 if (temp1)
12791 delete arg1;
12792 }
12793 return resultobj;
12794 fail:
12795 {
12796 if (temp1)
12797 delete arg1;
12798 }
12799 return NULL;
12800 }
12801
12802
12803 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12804 PyObject *resultobj = 0;
12805 wxImage *arg1 = (wxImage *) 0 ;
12806 void *argp1 = 0 ;
12807 int res1 = 0 ;
12808 PyObject *swig_obj[1] ;
12809
12810 if (!args) SWIG_fail;
12811 swig_obj[0] = args;
12812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12813 if (!SWIG_IsOK(res1)) {
12814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12815 }
12816 arg1 = reinterpret_cast< wxImage * >(argp1);
12817 {
12818 PyThreadState* __tstate = wxPyBeginAllowThreads();
12819 delete arg1;
12820
12821 wxPyEndAllowThreads(__tstate);
12822 if (PyErr_Occurred()) SWIG_fail;
12823 }
12824 resultobj = SWIG_Py_Void();
12825 return resultobj;
12826 fail:
12827 return NULL;
12828 }
12829
12830
12831 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12832 PyObject *resultobj = 0;
12833 wxString *arg1 = 0 ;
12834 wxString *arg2 = 0 ;
12835 int arg3 = (int) -1 ;
12836 wxImage *result = 0 ;
12837 bool temp1 = false ;
12838 bool temp2 = false ;
12839 int val3 ;
12840 int ecode3 = 0 ;
12841 PyObject * obj0 = 0 ;
12842 PyObject * obj1 = 0 ;
12843 PyObject * obj2 = 0 ;
12844 char * kwnames[] = {
12845 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12846 };
12847
12848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12849 {
12850 arg1 = wxString_in_helper(obj0);
12851 if (arg1 == NULL) SWIG_fail;
12852 temp1 = true;
12853 }
12854 {
12855 arg2 = wxString_in_helper(obj1);
12856 if (arg2 == NULL) SWIG_fail;
12857 temp2 = true;
12858 }
12859 if (obj2) {
12860 ecode3 = SWIG_AsVal_int(obj2, &val3);
12861 if (!SWIG_IsOK(ecode3)) {
12862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12863 }
12864 arg3 = static_cast< int >(val3);
12865 }
12866 {
12867 PyThreadState* __tstate = wxPyBeginAllowThreads();
12868 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12869 wxPyEndAllowThreads(__tstate);
12870 if (PyErr_Occurred()) SWIG_fail;
12871 }
12872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12873 {
12874 if (temp1)
12875 delete arg1;
12876 }
12877 {
12878 if (temp2)
12879 delete arg2;
12880 }
12881 return resultobj;
12882 fail:
12883 {
12884 if (temp1)
12885 delete arg1;
12886 }
12887 {
12888 if (temp2)
12889 delete arg2;
12890 }
12891 return NULL;
12892 }
12893
12894
12895 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12896 PyObject *resultobj = 0;
12897 wxInputStream *arg1 = 0 ;
12898 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12899 int arg3 = (int) -1 ;
12900 wxImage *result = 0 ;
12901 wxPyInputStream *temp1 ;
12902 bool created1 ;
12903 long val2 ;
12904 int ecode2 = 0 ;
12905 int val3 ;
12906 int ecode3 = 0 ;
12907 PyObject * obj0 = 0 ;
12908 PyObject * obj1 = 0 ;
12909 PyObject * obj2 = 0 ;
12910 char * kwnames[] = {
12911 (char *) "stream",(char *) "type",(char *) "index", NULL
12912 };
12913
12914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12915 {
12916 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12917 arg1 = temp1->m_wxis;
12918 created1 = false;
12919 } else {
12920 PyErr_Clear(); // clear the failure of the wxPyConvert above
12921 arg1 = wxPyCBInputStream_create(obj0, false);
12922 if (arg1 == NULL) {
12923 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12924 SWIG_fail;
12925 }
12926 created1 = true;
12927 }
12928 }
12929 if (obj1) {
12930 ecode2 = SWIG_AsVal_long(obj1, &val2);
12931 if (!SWIG_IsOK(ecode2)) {
12932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
12933 }
12934 arg2 = static_cast< long >(val2);
12935 }
12936 if (obj2) {
12937 ecode3 = SWIG_AsVal_int(obj2, &val3);
12938 if (!SWIG_IsOK(ecode3)) {
12939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
12940 }
12941 arg3 = static_cast< int >(val3);
12942 }
12943 {
12944 PyThreadState* __tstate = wxPyBeginAllowThreads();
12945 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
12946 wxPyEndAllowThreads(__tstate);
12947 if (PyErr_Occurred()) SWIG_fail;
12948 }
12949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12950 {
12951 if (created1) delete arg1;
12952 }
12953 return resultobj;
12954 fail:
12955 {
12956 if (created1) delete arg1;
12957 }
12958 return NULL;
12959 }
12960
12961
12962 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12963 PyObject *resultobj = 0;
12964 wxInputStream *arg1 = 0 ;
12965 wxString *arg2 = 0 ;
12966 int arg3 = (int) -1 ;
12967 wxImage *result = 0 ;
12968 wxPyInputStream *temp1 ;
12969 bool created1 ;
12970 bool temp2 = false ;
12971 int val3 ;
12972 int ecode3 = 0 ;
12973 PyObject * obj0 = 0 ;
12974 PyObject * obj1 = 0 ;
12975 PyObject * obj2 = 0 ;
12976 char * kwnames[] = {
12977 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
12978 };
12979
12980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12981 {
12982 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12983 arg1 = temp1->m_wxis;
12984 created1 = false;
12985 } else {
12986 PyErr_Clear(); // clear the failure of the wxPyConvert above
12987 arg1 = wxPyCBInputStream_create(obj0, false);
12988 if (arg1 == NULL) {
12989 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12990 SWIG_fail;
12991 }
12992 created1 = true;
12993 }
12994 }
12995 {
12996 arg2 = wxString_in_helper(obj1);
12997 if (arg2 == NULL) SWIG_fail;
12998 temp2 = true;
12999 }
13000 if (obj2) {
13001 ecode3 = SWIG_AsVal_int(obj2, &val3);
13002 if (!SWIG_IsOK(ecode3)) {
13003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13004 }
13005 arg3 = static_cast< int >(val3);
13006 }
13007 {
13008 PyThreadState* __tstate = wxPyBeginAllowThreads();
13009 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13010 wxPyEndAllowThreads(__tstate);
13011 if (PyErr_Occurred()) SWIG_fail;
13012 }
13013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13014 {
13015 if (created1) delete arg1;
13016 }
13017 {
13018 if (temp2)
13019 delete arg2;
13020 }
13021 return resultobj;
13022 fail:
13023 {
13024 if (created1) delete arg1;
13025 }
13026 {
13027 if (temp2)
13028 delete arg2;
13029 }
13030 return NULL;
13031 }
13032
13033
13034 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13035 PyObject *resultobj = 0;
13036 int arg1 = (int) 0 ;
13037 int arg2 = (int) 0 ;
13038 bool arg3 = (bool) true ;
13039 wxImage *result = 0 ;
13040 int val1 ;
13041 int ecode1 = 0 ;
13042 int val2 ;
13043 int ecode2 = 0 ;
13044 bool val3 ;
13045 int ecode3 = 0 ;
13046 PyObject * obj0 = 0 ;
13047 PyObject * obj1 = 0 ;
13048 PyObject * obj2 = 0 ;
13049 char * kwnames[] = {
13050 (char *) "width",(char *) "height",(char *) "clear", NULL
13051 };
13052
13053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13054 if (obj0) {
13055 ecode1 = SWIG_AsVal_int(obj0, &val1);
13056 if (!SWIG_IsOK(ecode1)) {
13057 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13058 }
13059 arg1 = static_cast< int >(val1);
13060 }
13061 if (obj1) {
13062 ecode2 = SWIG_AsVal_int(obj1, &val2);
13063 if (!SWIG_IsOK(ecode2)) {
13064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13065 }
13066 arg2 = static_cast< int >(val2);
13067 }
13068 if (obj2) {
13069 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13070 if (!SWIG_IsOK(ecode3)) {
13071 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13072 }
13073 arg3 = static_cast< bool >(val3);
13074 }
13075 {
13076 PyThreadState* __tstate = wxPyBeginAllowThreads();
13077 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13078 wxPyEndAllowThreads(__tstate);
13079 if (PyErr_Occurred()) SWIG_fail;
13080 }
13081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13082 return resultobj;
13083 fail:
13084 return NULL;
13085 }
13086
13087
13088 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13089 PyObject *resultobj = 0;
13090 wxBitmap *arg1 = 0 ;
13091 wxImage *result = 0 ;
13092 void *argp1 = 0 ;
13093 int res1 = 0 ;
13094 PyObject * obj0 = 0 ;
13095 char * kwnames[] = {
13096 (char *) "bitmap", NULL
13097 };
13098
13099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13100 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13101 if (!SWIG_IsOK(res1)) {
13102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13103 }
13104 if (!argp1) {
13105 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13106 }
13107 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13108 {
13109 if (!wxPyCheckForApp()) SWIG_fail;
13110 PyThreadState* __tstate = wxPyBeginAllowThreads();
13111 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13112 wxPyEndAllowThreads(__tstate);
13113 if (PyErr_Occurred()) SWIG_fail;
13114 }
13115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13116 return resultobj;
13117 fail:
13118 return NULL;
13119 }
13120
13121
13122 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13123 PyObject *resultobj = 0;
13124 int arg1 ;
13125 int arg2 ;
13126 buffer arg3 ;
13127 int arg4 ;
13128 wxImage *result = 0 ;
13129 int val1 ;
13130 int ecode1 = 0 ;
13131 int val2 ;
13132 int ecode2 = 0 ;
13133 PyObject * obj0 = 0 ;
13134 PyObject * obj1 = 0 ;
13135 PyObject * obj2 = 0 ;
13136 char * kwnames[] = {
13137 (char *) "width",(char *) "height",(char *) "data", NULL
13138 };
13139
13140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13141 ecode1 = SWIG_AsVal_int(obj0, &val1);
13142 if (!SWIG_IsOK(ecode1)) {
13143 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13144 }
13145 arg1 = static_cast< int >(val1);
13146 ecode2 = SWIG_AsVal_int(obj1, &val2);
13147 if (!SWIG_IsOK(ecode2)) {
13148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13149 }
13150 arg2 = static_cast< int >(val2);
13151 {
13152 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13153 }
13154 {
13155 PyThreadState* __tstate = wxPyBeginAllowThreads();
13156 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13157 wxPyEndAllowThreads(__tstate);
13158 if (PyErr_Occurred()) SWIG_fail;
13159 }
13160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13161 return resultobj;
13162 fail:
13163 return NULL;
13164 }
13165
13166
13167 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13168 PyObject *resultobj = 0;
13169 int arg1 ;
13170 int arg2 ;
13171 buffer arg3 ;
13172 int arg4 ;
13173 buffer arg5 ;
13174 int arg6 ;
13175 wxImage *result = 0 ;
13176 int val1 ;
13177 int ecode1 = 0 ;
13178 int val2 ;
13179 int ecode2 = 0 ;
13180 PyObject * obj0 = 0 ;
13181 PyObject * obj1 = 0 ;
13182 PyObject * obj2 = 0 ;
13183 PyObject * obj3 = 0 ;
13184 char * kwnames[] = {
13185 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13186 };
13187
13188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13189 ecode1 = SWIG_AsVal_int(obj0, &val1);
13190 if (!SWIG_IsOK(ecode1)) {
13191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13192 }
13193 arg1 = static_cast< int >(val1);
13194 ecode2 = SWIG_AsVal_int(obj1, &val2);
13195 if (!SWIG_IsOK(ecode2)) {
13196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13197 }
13198 arg2 = static_cast< int >(val2);
13199 {
13200 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13201 }
13202 {
13203 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13204 }
13205 {
13206 PyThreadState* __tstate = wxPyBeginAllowThreads();
13207 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13208 wxPyEndAllowThreads(__tstate);
13209 if (PyErr_Occurred()) SWIG_fail;
13210 }
13211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13212 return resultobj;
13213 fail:
13214 return NULL;
13215 }
13216
13217
13218 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13219 PyObject *resultobj = 0;
13220 wxImage *arg1 = (wxImage *) 0 ;
13221 int arg2 ;
13222 int arg3 ;
13223 bool arg4 = (bool) true ;
13224 void *argp1 = 0 ;
13225 int res1 = 0 ;
13226 int val2 ;
13227 int ecode2 = 0 ;
13228 int val3 ;
13229 int ecode3 = 0 ;
13230 bool val4 ;
13231 int ecode4 = 0 ;
13232 PyObject * obj0 = 0 ;
13233 PyObject * obj1 = 0 ;
13234 PyObject * obj2 = 0 ;
13235 PyObject * obj3 = 0 ;
13236 char * kwnames[] = {
13237 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13238 };
13239
13240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13242 if (!SWIG_IsOK(res1)) {
13243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13244 }
13245 arg1 = reinterpret_cast< wxImage * >(argp1);
13246 ecode2 = SWIG_AsVal_int(obj1, &val2);
13247 if (!SWIG_IsOK(ecode2)) {
13248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13249 }
13250 arg2 = static_cast< int >(val2);
13251 ecode3 = SWIG_AsVal_int(obj2, &val3);
13252 if (!SWIG_IsOK(ecode3)) {
13253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13254 }
13255 arg3 = static_cast< int >(val3);
13256 if (obj3) {
13257 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13258 if (!SWIG_IsOK(ecode4)) {
13259 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13260 }
13261 arg4 = static_cast< bool >(val4);
13262 }
13263 {
13264 PyThreadState* __tstate = wxPyBeginAllowThreads();
13265 (arg1)->Create(arg2,arg3,arg4);
13266 wxPyEndAllowThreads(__tstate);
13267 if (PyErr_Occurred()) SWIG_fail;
13268 }
13269 resultobj = SWIG_Py_Void();
13270 return resultobj;
13271 fail:
13272 return NULL;
13273 }
13274
13275
13276 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13277 PyObject *resultobj = 0;
13278 wxImage *arg1 = (wxImage *) 0 ;
13279 void *argp1 = 0 ;
13280 int res1 = 0 ;
13281 PyObject *swig_obj[1] ;
13282
13283 if (!args) SWIG_fail;
13284 swig_obj[0] = args;
13285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13286 if (!SWIG_IsOK(res1)) {
13287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13288 }
13289 arg1 = reinterpret_cast< wxImage * >(argp1);
13290 {
13291 PyThreadState* __tstate = wxPyBeginAllowThreads();
13292 (arg1)->Destroy();
13293 wxPyEndAllowThreads(__tstate);
13294 if (PyErr_Occurred()) SWIG_fail;
13295 }
13296 resultobj = SWIG_Py_Void();
13297 return resultobj;
13298 fail:
13299 return NULL;
13300 }
13301
13302
13303 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13304 PyObject *resultobj = 0;
13305 wxImage *arg1 = (wxImage *) 0 ;
13306 int arg2 ;
13307 int arg3 ;
13308 SwigValueWrapper<wxImage > result;
13309 void *argp1 = 0 ;
13310 int res1 = 0 ;
13311 int val2 ;
13312 int ecode2 = 0 ;
13313 int val3 ;
13314 int ecode3 = 0 ;
13315 PyObject * obj0 = 0 ;
13316 PyObject * obj1 = 0 ;
13317 PyObject * obj2 = 0 ;
13318 char * kwnames[] = {
13319 (char *) "self",(char *) "width",(char *) "height", NULL
13320 };
13321
13322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13324 if (!SWIG_IsOK(res1)) {
13325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13326 }
13327 arg1 = reinterpret_cast< wxImage * >(argp1);
13328 ecode2 = SWIG_AsVal_int(obj1, &val2);
13329 if (!SWIG_IsOK(ecode2)) {
13330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13331 }
13332 arg2 = static_cast< int >(val2);
13333 ecode3 = SWIG_AsVal_int(obj2, &val3);
13334 if (!SWIG_IsOK(ecode3)) {
13335 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13336 }
13337 arg3 = static_cast< int >(val3);
13338 {
13339 PyThreadState* __tstate = wxPyBeginAllowThreads();
13340 result = (arg1)->Scale(arg2,arg3);
13341 wxPyEndAllowThreads(__tstate);
13342 if (PyErr_Occurred()) SWIG_fail;
13343 }
13344 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13345 return resultobj;
13346 fail:
13347 return NULL;
13348 }
13349
13350
13351 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13352 PyObject *resultobj = 0;
13353 wxImage *arg1 = (wxImage *) 0 ;
13354 int arg2 ;
13355 int arg3 ;
13356 SwigValueWrapper<wxImage > result;
13357 void *argp1 = 0 ;
13358 int res1 = 0 ;
13359 int val2 ;
13360 int ecode2 = 0 ;
13361 int val3 ;
13362 int ecode3 = 0 ;
13363 PyObject * obj0 = 0 ;
13364 PyObject * obj1 = 0 ;
13365 PyObject * obj2 = 0 ;
13366 char * kwnames[] = {
13367 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13368 };
13369
13370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13372 if (!SWIG_IsOK(res1)) {
13373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13374 }
13375 arg1 = reinterpret_cast< wxImage * >(argp1);
13376 ecode2 = SWIG_AsVal_int(obj1, &val2);
13377 if (!SWIG_IsOK(ecode2)) {
13378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13379 }
13380 arg2 = static_cast< int >(val2);
13381 ecode3 = SWIG_AsVal_int(obj2, &val3);
13382 if (!SWIG_IsOK(ecode3)) {
13383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13384 }
13385 arg3 = static_cast< int >(val3);
13386 {
13387 PyThreadState* __tstate = wxPyBeginAllowThreads();
13388 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13389 wxPyEndAllowThreads(__tstate);
13390 if (PyErr_Occurred()) SWIG_fail;
13391 }
13392 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13393 return resultobj;
13394 fail:
13395 return NULL;
13396 }
13397
13398
13399 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13400 PyObject *resultobj = 0;
13401 wxImage *arg1 = (wxImage *) 0 ;
13402 int arg2 ;
13403 int arg3 ;
13404 wxImage *result = 0 ;
13405 void *argp1 = 0 ;
13406 int res1 = 0 ;
13407 int val2 ;
13408 int ecode2 = 0 ;
13409 int val3 ;
13410 int ecode3 = 0 ;
13411 PyObject * obj0 = 0 ;
13412 PyObject * obj1 = 0 ;
13413 PyObject * obj2 = 0 ;
13414 char * kwnames[] = {
13415 (char *) "self",(char *) "width",(char *) "height", NULL
13416 };
13417
13418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13420 if (!SWIG_IsOK(res1)) {
13421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13422 }
13423 arg1 = reinterpret_cast< wxImage * >(argp1);
13424 ecode2 = SWIG_AsVal_int(obj1, &val2);
13425 if (!SWIG_IsOK(ecode2)) {
13426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13427 }
13428 arg2 = static_cast< int >(val2);
13429 ecode3 = SWIG_AsVal_int(obj2, &val3);
13430 if (!SWIG_IsOK(ecode3)) {
13431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13432 }
13433 arg3 = static_cast< int >(val3);
13434 {
13435 PyThreadState* __tstate = wxPyBeginAllowThreads();
13436 {
13437 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13438 result = (wxImage *) &_result_ref;
13439 }
13440 wxPyEndAllowThreads(__tstate);
13441 if (PyErr_Occurred()) SWIG_fail;
13442 }
13443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13444 return resultobj;
13445 fail:
13446 return NULL;
13447 }
13448
13449
13450 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13451 PyObject *resultobj = 0;
13452 wxImage *arg1 = (wxImage *) 0 ;
13453 wxSize *arg2 = 0 ;
13454 wxPoint *arg3 = 0 ;
13455 int arg4 = (int) -1 ;
13456 int arg5 = (int) -1 ;
13457 int arg6 = (int) -1 ;
13458 wxImage *result = 0 ;
13459 void *argp1 = 0 ;
13460 int res1 = 0 ;
13461 wxSize temp2 ;
13462 wxPoint temp3 ;
13463 int val4 ;
13464 int ecode4 = 0 ;
13465 int val5 ;
13466 int ecode5 = 0 ;
13467 int val6 ;
13468 int ecode6 = 0 ;
13469 PyObject * obj0 = 0 ;
13470 PyObject * obj1 = 0 ;
13471 PyObject * obj2 = 0 ;
13472 PyObject * obj3 = 0 ;
13473 PyObject * obj4 = 0 ;
13474 PyObject * obj5 = 0 ;
13475 char * kwnames[] = {
13476 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13477 };
13478
13479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13481 if (!SWIG_IsOK(res1)) {
13482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13483 }
13484 arg1 = reinterpret_cast< wxImage * >(argp1);
13485 {
13486 arg2 = &temp2;
13487 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13488 }
13489 {
13490 arg3 = &temp3;
13491 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13492 }
13493 if (obj3) {
13494 ecode4 = SWIG_AsVal_int(obj3, &val4);
13495 if (!SWIG_IsOK(ecode4)) {
13496 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13497 }
13498 arg4 = static_cast< int >(val4);
13499 }
13500 if (obj4) {
13501 ecode5 = SWIG_AsVal_int(obj4, &val5);
13502 if (!SWIG_IsOK(ecode5)) {
13503 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13504 }
13505 arg5 = static_cast< int >(val5);
13506 }
13507 if (obj5) {
13508 ecode6 = SWIG_AsVal_int(obj5, &val6);
13509 if (!SWIG_IsOK(ecode6)) {
13510 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13511 }
13512 arg6 = static_cast< int >(val6);
13513 }
13514 {
13515 PyThreadState* __tstate = wxPyBeginAllowThreads();
13516 {
13517 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13518 result = (wxImage *) &_result_ref;
13519 }
13520 wxPyEndAllowThreads(__tstate);
13521 if (PyErr_Occurred()) SWIG_fail;
13522 }
13523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13524 return resultobj;
13525 fail:
13526 return NULL;
13527 }
13528
13529
13530 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13531 PyObject *resultobj = 0;
13532 wxImage *arg1 = (wxImage *) 0 ;
13533 int arg2 ;
13534 int arg3 ;
13535 byte arg4 ;
13536 byte arg5 ;
13537 byte arg6 ;
13538 void *argp1 = 0 ;
13539 int res1 = 0 ;
13540 int val2 ;
13541 int ecode2 = 0 ;
13542 int val3 ;
13543 int ecode3 = 0 ;
13544 unsigned char val4 ;
13545 int ecode4 = 0 ;
13546 unsigned char val5 ;
13547 int ecode5 = 0 ;
13548 unsigned char val6 ;
13549 int ecode6 = 0 ;
13550 PyObject * obj0 = 0 ;
13551 PyObject * obj1 = 0 ;
13552 PyObject * obj2 = 0 ;
13553 PyObject * obj3 = 0 ;
13554 PyObject * obj4 = 0 ;
13555 PyObject * obj5 = 0 ;
13556 char * kwnames[] = {
13557 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13558 };
13559
13560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13562 if (!SWIG_IsOK(res1)) {
13563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13564 }
13565 arg1 = reinterpret_cast< wxImage * >(argp1);
13566 ecode2 = SWIG_AsVal_int(obj1, &val2);
13567 if (!SWIG_IsOK(ecode2)) {
13568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13569 }
13570 arg2 = static_cast< int >(val2);
13571 ecode3 = SWIG_AsVal_int(obj2, &val3);
13572 if (!SWIG_IsOK(ecode3)) {
13573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13574 }
13575 arg3 = static_cast< int >(val3);
13576 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13577 if (!SWIG_IsOK(ecode4)) {
13578 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13579 }
13580 arg4 = static_cast< byte >(val4);
13581 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13582 if (!SWIG_IsOK(ecode5)) {
13583 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13584 }
13585 arg5 = static_cast< byte >(val5);
13586 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13587 if (!SWIG_IsOK(ecode6)) {
13588 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13589 }
13590 arg6 = static_cast< byte >(val6);
13591 {
13592 PyThreadState* __tstate = wxPyBeginAllowThreads();
13593 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13594 wxPyEndAllowThreads(__tstate);
13595 if (PyErr_Occurred()) SWIG_fail;
13596 }
13597 resultobj = SWIG_Py_Void();
13598 return resultobj;
13599 fail:
13600 return NULL;
13601 }
13602
13603
13604 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13605 PyObject *resultobj = 0;
13606 wxImage *arg1 = (wxImage *) 0 ;
13607 wxRect *arg2 = 0 ;
13608 byte arg3 ;
13609 byte arg4 ;
13610 byte arg5 ;
13611 void *argp1 = 0 ;
13612 int res1 = 0 ;
13613 wxRect temp2 ;
13614 unsigned char val3 ;
13615 int ecode3 = 0 ;
13616 unsigned char val4 ;
13617 int ecode4 = 0 ;
13618 unsigned char val5 ;
13619 int ecode5 = 0 ;
13620 PyObject * obj0 = 0 ;
13621 PyObject * obj1 = 0 ;
13622 PyObject * obj2 = 0 ;
13623 PyObject * obj3 = 0 ;
13624 PyObject * obj4 = 0 ;
13625 char * kwnames[] = {
13626 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13627 };
13628
13629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13631 if (!SWIG_IsOK(res1)) {
13632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13633 }
13634 arg1 = reinterpret_cast< wxImage * >(argp1);
13635 {
13636 arg2 = &temp2;
13637 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13638 }
13639 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13640 if (!SWIG_IsOK(ecode3)) {
13641 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13642 }
13643 arg3 = static_cast< byte >(val3);
13644 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13645 if (!SWIG_IsOK(ecode4)) {
13646 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13647 }
13648 arg4 = static_cast< byte >(val4);
13649 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13650 if (!SWIG_IsOK(ecode5)) {
13651 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13652 }
13653 arg5 = static_cast< byte >(val5);
13654 {
13655 PyThreadState* __tstate = wxPyBeginAllowThreads();
13656 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13657 wxPyEndAllowThreads(__tstate);
13658 if (PyErr_Occurred()) SWIG_fail;
13659 }
13660 resultobj = SWIG_Py_Void();
13661 return resultobj;
13662 fail:
13663 return NULL;
13664 }
13665
13666
13667 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13668 PyObject *resultobj = 0;
13669 wxImage *arg1 = (wxImage *) 0 ;
13670 int arg2 ;
13671 int arg3 ;
13672 byte result;
13673 void *argp1 = 0 ;
13674 int res1 = 0 ;
13675 int val2 ;
13676 int ecode2 = 0 ;
13677 int val3 ;
13678 int ecode3 = 0 ;
13679 PyObject * obj0 = 0 ;
13680 PyObject * obj1 = 0 ;
13681 PyObject * obj2 = 0 ;
13682 char * kwnames[] = {
13683 (char *) "self",(char *) "x",(char *) "y", NULL
13684 };
13685
13686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13688 if (!SWIG_IsOK(res1)) {
13689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13690 }
13691 arg1 = reinterpret_cast< wxImage * >(argp1);
13692 ecode2 = SWIG_AsVal_int(obj1, &val2);
13693 if (!SWIG_IsOK(ecode2)) {
13694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13695 }
13696 arg2 = static_cast< int >(val2);
13697 ecode3 = SWIG_AsVal_int(obj2, &val3);
13698 if (!SWIG_IsOK(ecode3)) {
13699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13700 }
13701 arg3 = static_cast< int >(val3);
13702 {
13703 PyThreadState* __tstate = wxPyBeginAllowThreads();
13704 result = (byte)(arg1)->GetRed(arg2,arg3);
13705 wxPyEndAllowThreads(__tstate);
13706 if (PyErr_Occurred()) SWIG_fail;
13707 }
13708 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13709 return resultobj;
13710 fail:
13711 return NULL;
13712 }
13713
13714
13715 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13716 PyObject *resultobj = 0;
13717 wxImage *arg1 = (wxImage *) 0 ;
13718 int arg2 ;
13719 int arg3 ;
13720 byte result;
13721 void *argp1 = 0 ;
13722 int res1 = 0 ;
13723 int val2 ;
13724 int ecode2 = 0 ;
13725 int val3 ;
13726 int ecode3 = 0 ;
13727 PyObject * obj0 = 0 ;
13728 PyObject * obj1 = 0 ;
13729 PyObject * obj2 = 0 ;
13730 char * kwnames[] = {
13731 (char *) "self",(char *) "x",(char *) "y", NULL
13732 };
13733
13734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13736 if (!SWIG_IsOK(res1)) {
13737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13738 }
13739 arg1 = reinterpret_cast< wxImage * >(argp1);
13740 ecode2 = SWIG_AsVal_int(obj1, &val2);
13741 if (!SWIG_IsOK(ecode2)) {
13742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13743 }
13744 arg2 = static_cast< int >(val2);
13745 ecode3 = SWIG_AsVal_int(obj2, &val3);
13746 if (!SWIG_IsOK(ecode3)) {
13747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13748 }
13749 arg3 = static_cast< int >(val3);
13750 {
13751 PyThreadState* __tstate = wxPyBeginAllowThreads();
13752 result = (byte)(arg1)->GetGreen(arg2,arg3);
13753 wxPyEndAllowThreads(__tstate);
13754 if (PyErr_Occurred()) SWIG_fail;
13755 }
13756 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13757 return resultobj;
13758 fail:
13759 return NULL;
13760 }
13761
13762
13763 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13764 PyObject *resultobj = 0;
13765 wxImage *arg1 = (wxImage *) 0 ;
13766 int arg2 ;
13767 int arg3 ;
13768 byte result;
13769 void *argp1 = 0 ;
13770 int res1 = 0 ;
13771 int val2 ;
13772 int ecode2 = 0 ;
13773 int val3 ;
13774 int ecode3 = 0 ;
13775 PyObject * obj0 = 0 ;
13776 PyObject * obj1 = 0 ;
13777 PyObject * obj2 = 0 ;
13778 char * kwnames[] = {
13779 (char *) "self",(char *) "x",(char *) "y", NULL
13780 };
13781
13782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13784 if (!SWIG_IsOK(res1)) {
13785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13786 }
13787 arg1 = reinterpret_cast< wxImage * >(argp1);
13788 ecode2 = SWIG_AsVal_int(obj1, &val2);
13789 if (!SWIG_IsOK(ecode2)) {
13790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13791 }
13792 arg2 = static_cast< int >(val2);
13793 ecode3 = SWIG_AsVal_int(obj2, &val3);
13794 if (!SWIG_IsOK(ecode3)) {
13795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13796 }
13797 arg3 = static_cast< int >(val3);
13798 {
13799 PyThreadState* __tstate = wxPyBeginAllowThreads();
13800 result = (byte)(arg1)->GetBlue(arg2,arg3);
13801 wxPyEndAllowThreads(__tstate);
13802 if (PyErr_Occurred()) SWIG_fail;
13803 }
13804 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13805 return resultobj;
13806 fail:
13807 return NULL;
13808 }
13809
13810
13811 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13812 PyObject *resultobj = 0;
13813 wxImage *arg1 = (wxImage *) 0 ;
13814 int arg2 ;
13815 int arg3 ;
13816 byte arg4 ;
13817 void *argp1 = 0 ;
13818 int res1 = 0 ;
13819 int val2 ;
13820 int ecode2 = 0 ;
13821 int val3 ;
13822 int ecode3 = 0 ;
13823 unsigned char val4 ;
13824 int ecode4 = 0 ;
13825 PyObject * obj0 = 0 ;
13826 PyObject * obj1 = 0 ;
13827 PyObject * obj2 = 0 ;
13828 PyObject * obj3 = 0 ;
13829 char * kwnames[] = {
13830 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13831 };
13832
13833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13835 if (!SWIG_IsOK(res1)) {
13836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13837 }
13838 arg1 = reinterpret_cast< wxImage * >(argp1);
13839 ecode2 = SWIG_AsVal_int(obj1, &val2);
13840 if (!SWIG_IsOK(ecode2)) {
13841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13842 }
13843 arg2 = static_cast< int >(val2);
13844 ecode3 = SWIG_AsVal_int(obj2, &val3);
13845 if (!SWIG_IsOK(ecode3)) {
13846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13847 }
13848 arg3 = static_cast< int >(val3);
13849 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13850 if (!SWIG_IsOK(ecode4)) {
13851 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13852 }
13853 arg4 = static_cast< byte >(val4);
13854 {
13855 PyThreadState* __tstate = wxPyBeginAllowThreads();
13856 (arg1)->SetAlpha(arg2,arg3,arg4);
13857 wxPyEndAllowThreads(__tstate);
13858 if (PyErr_Occurred()) SWIG_fail;
13859 }
13860 resultobj = SWIG_Py_Void();
13861 return resultobj;
13862 fail:
13863 return NULL;
13864 }
13865
13866
13867 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13868 PyObject *resultobj = 0;
13869 wxImage *arg1 = (wxImage *) 0 ;
13870 int arg2 ;
13871 int arg3 ;
13872 byte result;
13873 void *argp1 = 0 ;
13874 int res1 = 0 ;
13875 int val2 ;
13876 int ecode2 = 0 ;
13877 int val3 ;
13878 int ecode3 = 0 ;
13879 PyObject * obj0 = 0 ;
13880 PyObject * obj1 = 0 ;
13881 PyObject * obj2 = 0 ;
13882 char * kwnames[] = {
13883 (char *) "self",(char *) "x",(char *) "y", NULL
13884 };
13885
13886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13888 if (!SWIG_IsOK(res1)) {
13889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13890 }
13891 arg1 = reinterpret_cast< wxImage * >(argp1);
13892 ecode2 = SWIG_AsVal_int(obj1, &val2);
13893 if (!SWIG_IsOK(ecode2)) {
13894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
13895 }
13896 arg2 = static_cast< int >(val2);
13897 ecode3 = SWIG_AsVal_int(obj2, &val3);
13898 if (!SWIG_IsOK(ecode3)) {
13899 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
13900 }
13901 arg3 = static_cast< int >(val3);
13902 {
13903 PyThreadState* __tstate = wxPyBeginAllowThreads();
13904 result = (byte)(arg1)->GetAlpha(arg2,arg3);
13905 wxPyEndAllowThreads(__tstate);
13906 if (PyErr_Occurred()) SWIG_fail;
13907 }
13908 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13909 return resultobj;
13910 fail:
13911 return NULL;
13912 }
13913
13914
13915 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13916 PyObject *resultobj = 0;
13917 wxImage *arg1 = (wxImage *) 0 ;
13918 bool result;
13919 void *argp1 = 0 ;
13920 int res1 = 0 ;
13921 PyObject *swig_obj[1] ;
13922
13923 if (!args) SWIG_fail;
13924 swig_obj[0] = args;
13925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13926 if (!SWIG_IsOK(res1)) {
13927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13928 }
13929 arg1 = reinterpret_cast< wxImage * >(argp1);
13930 {
13931 PyThreadState* __tstate = wxPyBeginAllowThreads();
13932 result = (bool)(arg1)->HasAlpha();
13933 wxPyEndAllowThreads(__tstate);
13934 if (PyErr_Occurred()) SWIG_fail;
13935 }
13936 {
13937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13938 }
13939 return resultobj;
13940 fail:
13941 return NULL;
13942 }
13943
13944
13945 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13946 PyObject *resultobj = 0;
13947 wxImage *arg1 = (wxImage *) 0 ;
13948 void *argp1 = 0 ;
13949 int res1 = 0 ;
13950 PyObject *swig_obj[1] ;
13951
13952 if (!args) SWIG_fail;
13953 swig_obj[0] = args;
13954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13955 if (!SWIG_IsOK(res1)) {
13956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13957 }
13958 arg1 = reinterpret_cast< wxImage * >(argp1);
13959 {
13960 PyThreadState* __tstate = wxPyBeginAllowThreads();
13961 (arg1)->InitAlpha();
13962 wxPyEndAllowThreads(__tstate);
13963 if (PyErr_Occurred()) SWIG_fail;
13964 }
13965 resultobj = SWIG_Py_Void();
13966 return resultobj;
13967 fail:
13968 return NULL;
13969 }
13970
13971
13972 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13973 PyObject *resultobj = 0;
13974 wxImage *arg1 = (wxImage *) 0 ;
13975 int arg2 ;
13976 int arg3 ;
13977 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
13978 bool result;
13979 void *argp1 = 0 ;
13980 int res1 = 0 ;
13981 int val2 ;
13982 int ecode2 = 0 ;
13983 int val3 ;
13984 int ecode3 = 0 ;
13985 unsigned char val4 ;
13986 int ecode4 = 0 ;
13987 PyObject * obj0 = 0 ;
13988 PyObject * obj1 = 0 ;
13989 PyObject * obj2 = 0 ;
13990 PyObject * obj3 = 0 ;
13991 char * kwnames[] = {
13992 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
13993 };
13994
13995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13997 if (!SWIG_IsOK(res1)) {
13998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
13999 }
14000 arg1 = reinterpret_cast< wxImage * >(argp1);
14001 ecode2 = SWIG_AsVal_int(obj1, &val2);
14002 if (!SWIG_IsOK(ecode2)) {
14003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14004 }
14005 arg2 = static_cast< int >(val2);
14006 ecode3 = SWIG_AsVal_int(obj2, &val3);
14007 if (!SWIG_IsOK(ecode3)) {
14008 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14009 }
14010 arg3 = static_cast< int >(val3);
14011 if (obj3) {
14012 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14013 if (!SWIG_IsOK(ecode4)) {
14014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14015 }
14016 arg4 = static_cast< byte >(val4);
14017 }
14018 {
14019 PyThreadState* __tstate = wxPyBeginAllowThreads();
14020 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14021 wxPyEndAllowThreads(__tstate);
14022 if (PyErr_Occurred()) SWIG_fail;
14023 }
14024 {
14025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14026 }
14027 return resultobj;
14028 fail:
14029 return NULL;
14030 }
14031
14032
14033 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14034 PyObject *resultobj = 0;
14035 wxImage *arg1 = (wxImage *) 0 ;
14036 byte *arg2 = (byte *) 0 ;
14037 byte *arg3 = (byte *) 0 ;
14038 byte *arg4 = (byte *) 0 ;
14039 byte arg5 = (byte) 0 ;
14040 byte arg6 = (byte) 0 ;
14041 byte arg7 = (byte) 0 ;
14042 bool result;
14043 void *argp1 = 0 ;
14044 int res1 = 0 ;
14045 byte temp2 ;
14046 int res2 = SWIG_TMPOBJ ;
14047 byte temp3 ;
14048 int res3 = SWIG_TMPOBJ ;
14049 byte temp4 ;
14050 int res4 = SWIG_TMPOBJ ;
14051 unsigned char val5 ;
14052 int ecode5 = 0 ;
14053 unsigned char val6 ;
14054 int ecode6 = 0 ;
14055 unsigned char val7 ;
14056 int ecode7 = 0 ;
14057 PyObject * obj0 = 0 ;
14058 PyObject * obj1 = 0 ;
14059 PyObject * obj2 = 0 ;
14060 PyObject * obj3 = 0 ;
14061 char * kwnames[] = {
14062 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14063 };
14064
14065 arg2 = &temp2;
14066 arg3 = &temp3;
14067 arg4 = &temp4;
14068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14070 if (!SWIG_IsOK(res1)) {
14071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14072 }
14073 arg1 = reinterpret_cast< wxImage * >(argp1);
14074 if (obj1) {
14075 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14076 if (!SWIG_IsOK(ecode5)) {
14077 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14078 }
14079 arg5 = static_cast< byte >(val5);
14080 }
14081 if (obj2) {
14082 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14083 if (!SWIG_IsOK(ecode6)) {
14084 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14085 }
14086 arg6 = static_cast< byte >(val6);
14087 }
14088 if (obj3) {
14089 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14090 if (!SWIG_IsOK(ecode7)) {
14091 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14092 }
14093 arg7 = static_cast< byte >(val7);
14094 }
14095 {
14096 PyThreadState* __tstate = wxPyBeginAllowThreads();
14097 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14098 wxPyEndAllowThreads(__tstate);
14099 if (PyErr_Occurred()) SWIG_fail;
14100 }
14101 {
14102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14103 }
14104 if (SWIG_IsTmpObj(res2)) {
14105 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14106 } else {
14107 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14108 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14109 }
14110 if (SWIG_IsTmpObj(res3)) {
14111 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14112 } else {
14113 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14114 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14115 }
14116 if (SWIG_IsTmpObj(res4)) {
14117 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14118 } else {
14119 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14121 }
14122 return resultobj;
14123 fail:
14124 return NULL;
14125 }
14126
14127
14128 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14129 PyObject *resultobj = 0;
14130 wxImage *arg1 = (wxImage *) 0 ;
14131 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14132 bool result;
14133 void *argp1 = 0 ;
14134 int res1 = 0 ;
14135 unsigned char val2 ;
14136 int ecode2 = 0 ;
14137 PyObject * obj0 = 0 ;
14138 PyObject * obj1 = 0 ;
14139 char * kwnames[] = {
14140 (char *) "self",(char *) "threshold", NULL
14141 };
14142
14143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14145 if (!SWIG_IsOK(res1)) {
14146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14147 }
14148 arg1 = reinterpret_cast< wxImage * >(argp1);
14149 if (obj1) {
14150 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14151 if (!SWIG_IsOK(ecode2)) {
14152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14153 }
14154 arg2 = static_cast< byte >(val2);
14155 }
14156 {
14157 PyThreadState* __tstate = wxPyBeginAllowThreads();
14158 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14159 wxPyEndAllowThreads(__tstate);
14160 if (PyErr_Occurred()) SWIG_fail;
14161 }
14162 {
14163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14164 }
14165 return resultobj;
14166 fail:
14167 return NULL;
14168 }
14169
14170
14171 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14172 PyObject *resultobj = 0;
14173 wxImage *arg1 = (wxImage *) 0 ;
14174 byte arg2 ;
14175 byte arg3 ;
14176 byte arg4 ;
14177 bool result;
14178 void *argp1 = 0 ;
14179 int res1 = 0 ;
14180 unsigned char val2 ;
14181 int ecode2 = 0 ;
14182 unsigned char val3 ;
14183 int ecode3 = 0 ;
14184 unsigned char val4 ;
14185 int ecode4 = 0 ;
14186 PyObject * obj0 = 0 ;
14187 PyObject * obj1 = 0 ;
14188 PyObject * obj2 = 0 ;
14189 PyObject * obj3 = 0 ;
14190 char * kwnames[] = {
14191 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14192 };
14193
14194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14196 if (!SWIG_IsOK(res1)) {
14197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14198 }
14199 arg1 = reinterpret_cast< wxImage * >(argp1);
14200 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14201 if (!SWIG_IsOK(ecode2)) {
14202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14203 }
14204 arg2 = static_cast< byte >(val2);
14205 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14206 if (!SWIG_IsOK(ecode3)) {
14207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14208 }
14209 arg3 = static_cast< byte >(val3);
14210 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14211 if (!SWIG_IsOK(ecode4)) {
14212 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14213 }
14214 arg4 = static_cast< byte >(val4);
14215 {
14216 PyThreadState* __tstate = wxPyBeginAllowThreads();
14217 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14218 wxPyEndAllowThreads(__tstate);
14219 if (PyErr_Occurred()) SWIG_fail;
14220 }
14221 {
14222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14223 }
14224 return resultobj;
14225 fail:
14226 return NULL;
14227 }
14228
14229
14230 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14231 PyObject *resultobj = 0;
14232 wxImage *arg1 = (wxImage *) 0 ;
14233 wxImage *arg2 = 0 ;
14234 byte arg3 ;
14235 byte arg4 ;
14236 byte arg5 ;
14237 bool result;
14238 void *argp1 = 0 ;
14239 int res1 = 0 ;
14240 void *argp2 = 0 ;
14241 int res2 = 0 ;
14242 unsigned char val3 ;
14243 int ecode3 = 0 ;
14244 unsigned char val4 ;
14245 int ecode4 = 0 ;
14246 unsigned char val5 ;
14247 int ecode5 = 0 ;
14248 PyObject * obj0 = 0 ;
14249 PyObject * obj1 = 0 ;
14250 PyObject * obj2 = 0 ;
14251 PyObject * obj3 = 0 ;
14252 PyObject * obj4 = 0 ;
14253 char * kwnames[] = {
14254 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14255 };
14256
14257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14259 if (!SWIG_IsOK(res1)) {
14260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14261 }
14262 arg1 = reinterpret_cast< wxImage * >(argp1);
14263 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14264 if (!SWIG_IsOK(res2)) {
14265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14266 }
14267 if (!argp2) {
14268 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14269 }
14270 arg2 = reinterpret_cast< wxImage * >(argp2);
14271 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14272 if (!SWIG_IsOK(ecode3)) {
14273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14274 }
14275 arg3 = static_cast< byte >(val3);
14276 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14277 if (!SWIG_IsOK(ecode4)) {
14278 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14279 }
14280 arg4 = static_cast< byte >(val4);
14281 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14282 if (!SWIG_IsOK(ecode5)) {
14283 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14284 }
14285 arg5 = static_cast< byte >(val5);
14286 {
14287 PyThreadState* __tstate = wxPyBeginAllowThreads();
14288 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14289 wxPyEndAllowThreads(__tstate);
14290 if (PyErr_Occurred()) SWIG_fail;
14291 }
14292 {
14293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14294 }
14295 return resultobj;
14296 fail:
14297 return NULL;
14298 }
14299
14300
14301 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14302 PyObject *resultobj = 0;
14303 wxString *arg1 = 0 ;
14304 bool result;
14305 bool temp1 = false ;
14306 PyObject * obj0 = 0 ;
14307 char * kwnames[] = {
14308 (char *) "filename", NULL
14309 };
14310
14311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14312 {
14313 arg1 = wxString_in_helper(obj0);
14314 if (arg1 == NULL) SWIG_fail;
14315 temp1 = true;
14316 }
14317 {
14318 PyThreadState* __tstate = wxPyBeginAllowThreads();
14319 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14320 wxPyEndAllowThreads(__tstate);
14321 if (PyErr_Occurred()) SWIG_fail;
14322 }
14323 {
14324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14325 }
14326 {
14327 if (temp1)
14328 delete arg1;
14329 }
14330 return resultobj;
14331 fail:
14332 {
14333 if (temp1)
14334 delete arg1;
14335 }
14336 return NULL;
14337 }
14338
14339
14340 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14341 PyObject *resultobj = 0;
14342 wxString *arg1 = 0 ;
14343 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14344 int result;
14345 bool temp1 = false ;
14346 long val2 ;
14347 int ecode2 = 0 ;
14348 PyObject * obj0 = 0 ;
14349 PyObject * obj1 = 0 ;
14350 char * kwnames[] = {
14351 (char *) "filename",(char *) "type", NULL
14352 };
14353
14354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14355 {
14356 arg1 = wxString_in_helper(obj0);
14357 if (arg1 == NULL) SWIG_fail;
14358 temp1 = true;
14359 }
14360 if (obj1) {
14361 ecode2 = SWIG_AsVal_long(obj1, &val2);
14362 if (!SWIG_IsOK(ecode2)) {
14363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14364 }
14365 arg2 = static_cast< long >(val2);
14366 }
14367 {
14368 PyThreadState* __tstate = wxPyBeginAllowThreads();
14369 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14370 wxPyEndAllowThreads(__tstate);
14371 if (PyErr_Occurred()) SWIG_fail;
14372 }
14373 resultobj = SWIG_From_int(static_cast< int >(result));
14374 {
14375 if (temp1)
14376 delete arg1;
14377 }
14378 return resultobj;
14379 fail:
14380 {
14381 if (temp1)
14382 delete arg1;
14383 }
14384 return NULL;
14385 }
14386
14387
14388 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14389 PyObject *resultobj = 0;
14390 wxImage *arg1 = (wxImage *) 0 ;
14391 wxString *arg2 = 0 ;
14392 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14393 int arg4 = (int) -1 ;
14394 bool result;
14395 void *argp1 = 0 ;
14396 int res1 = 0 ;
14397 bool temp2 = false ;
14398 long val3 ;
14399 int ecode3 = 0 ;
14400 int val4 ;
14401 int ecode4 = 0 ;
14402 PyObject * obj0 = 0 ;
14403 PyObject * obj1 = 0 ;
14404 PyObject * obj2 = 0 ;
14405 PyObject * obj3 = 0 ;
14406 char * kwnames[] = {
14407 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14408 };
14409
14410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14412 if (!SWIG_IsOK(res1)) {
14413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14414 }
14415 arg1 = reinterpret_cast< wxImage * >(argp1);
14416 {
14417 arg2 = wxString_in_helper(obj1);
14418 if (arg2 == NULL) SWIG_fail;
14419 temp2 = true;
14420 }
14421 if (obj2) {
14422 ecode3 = SWIG_AsVal_long(obj2, &val3);
14423 if (!SWIG_IsOK(ecode3)) {
14424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14425 }
14426 arg3 = static_cast< long >(val3);
14427 }
14428 if (obj3) {
14429 ecode4 = SWIG_AsVal_int(obj3, &val4);
14430 if (!SWIG_IsOK(ecode4)) {
14431 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14432 }
14433 arg4 = static_cast< int >(val4);
14434 }
14435 {
14436 PyThreadState* __tstate = wxPyBeginAllowThreads();
14437 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14438 wxPyEndAllowThreads(__tstate);
14439 if (PyErr_Occurred()) SWIG_fail;
14440 }
14441 {
14442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14443 }
14444 {
14445 if (temp2)
14446 delete arg2;
14447 }
14448 return resultobj;
14449 fail:
14450 {
14451 if (temp2)
14452 delete arg2;
14453 }
14454 return NULL;
14455 }
14456
14457
14458 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14459 PyObject *resultobj = 0;
14460 wxImage *arg1 = (wxImage *) 0 ;
14461 wxString *arg2 = 0 ;
14462 wxString *arg3 = 0 ;
14463 int arg4 = (int) -1 ;
14464 bool result;
14465 void *argp1 = 0 ;
14466 int res1 = 0 ;
14467 bool temp2 = false ;
14468 bool temp3 = false ;
14469 int val4 ;
14470 int ecode4 = 0 ;
14471 PyObject * obj0 = 0 ;
14472 PyObject * obj1 = 0 ;
14473 PyObject * obj2 = 0 ;
14474 PyObject * obj3 = 0 ;
14475 char * kwnames[] = {
14476 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14477 };
14478
14479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14481 if (!SWIG_IsOK(res1)) {
14482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14483 }
14484 arg1 = reinterpret_cast< wxImage * >(argp1);
14485 {
14486 arg2 = wxString_in_helper(obj1);
14487 if (arg2 == NULL) SWIG_fail;
14488 temp2 = true;
14489 }
14490 {
14491 arg3 = wxString_in_helper(obj2);
14492 if (arg3 == NULL) SWIG_fail;
14493 temp3 = true;
14494 }
14495 if (obj3) {
14496 ecode4 = SWIG_AsVal_int(obj3, &val4);
14497 if (!SWIG_IsOK(ecode4)) {
14498 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14499 }
14500 arg4 = static_cast< int >(val4);
14501 }
14502 {
14503 PyThreadState* __tstate = wxPyBeginAllowThreads();
14504 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14505 wxPyEndAllowThreads(__tstate);
14506 if (PyErr_Occurred()) SWIG_fail;
14507 }
14508 {
14509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14510 }
14511 {
14512 if (temp2)
14513 delete arg2;
14514 }
14515 {
14516 if (temp3)
14517 delete arg3;
14518 }
14519 return resultobj;
14520 fail:
14521 {
14522 if (temp2)
14523 delete arg2;
14524 }
14525 {
14526 if (temp3)
14527 delete arg3;
14528 }
14529 return NULL;
14530 }
14531
14532
14533 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14534 PyObject *resultobj = 0;
14535 wxImage *arg1 = (wxImage *) 0 ;
14536 wxString *arg2 = 0 ;
14537 int arg3 ;
14538 bool result;
14539 void *argp1 = 0 ;
14540 int res1 = 0 ;
14541 bool temp2 = false ;
14542 int val3 ;
14543 int ecode3 = 0 ;
14544 PyObject * obj0 = 0 ;
14545 PyObject * obj1 = 0 ;
14546 PyObject * obj2 = 0 ;
14547 char * kwnames[] = {
14548 (char *) "self",(char *) "name",(char *) "type", NULL
14549 };
14550
14551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14553 if (!SWIG_IsOK(res1)) {
14554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14555 }
14556 arg1 = reinterpret_cast< wxImage * >(argp1);
14557 {
14558 arg2 = wxString_in_helper(obj1);
14559 if (arg2 == NULL) SWIG_fail;
14560 temp2 = true;
14561 }
14562 ecode3 = SWIG_AsVal_int(obj2, &val3);
14563 if (!SWIG_IsOK(ecode3)) {
14564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14565 }
14566 arg3 = static_cast< int >(val3);
14567 {
14568 PyThreadState* __tstate = wxPyBeginAllowThreads();
14569 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14570 wxPyEndAllowThreads(__tstate);
14571 if (PyErr_Occurred()) SWIG_fail;
14572 }
14573 {
14574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14575 }
14576 {
14577 if (temp2)
14578 delete arg2;
14579 }
14580 return resultobj;
14581 fail:
14582 {
14583 if (temp2)
14584 delete arg2;
14585 }
14586 return NULL;
14587 }
14588
14589
14590 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14591 PyObject *resultobj = 0;
14592 wxImage *arg1 = (wxImage *) 0 ;
14593 wxString *arg2 = 0 ;
14594 wxString *arg3 = 0 ;
14595 bool result;
14596 void *argp1 = 0 ;
14597 int res1 = 0 ;
14598 bool temp2 = false ;
14599 bool temp3 = false ;
14600 PyObject * obj0 = 0 ;
14601 PyObject * obj1 = 0 ;
14602 PyObject * obj2 = 0 ;
14603 char * kwnames[] = {
14604 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14605 };
14606
14607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14609 if (!SWIG_IsOK(res1)) {
14610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14611 }
14612 arg1 = reinterpret_cast< wxImage * >(argp1);
14613 {
14614 arg2 = wxString_in_helper(obj1);
14615 if (arg2 == NULL) SWIG_fail;
14616 temp2 = true;
14617 }
14618 {
14619 arg3 = wxString_in_helper(obj2);
14620 if (arg3 == NULL) SWIG_fail;
14621 temp3 = true;
14622 }
14623 {
14624 PyThreadState* __tstate = wxPyBeginAllowThreads();
14625 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14626 wxPyEndAllowThreads(__tstate);
14627 if (PyErr_Occurred()) SWIG_fail;
14628 }
14629 {
14630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14631 }
14632 {
14633 if (temp2)
14634 delete arg2;
14635 }
14636 {
14637 if (temp3)
14638 delete arg3;
14639 }
14640 return resultobj;
14641 fail:
14642 {
14643 if (temp2)
14644 delete arg2;
14645 }
14646 {
14647 if (temp3)
14648 delete arg3;
14649 }
14650 return NULL;
14651 }
14652
14653
14654 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14655 PyObject *resultobj = 0;
14656 wxInputStream *arg1 = 0 ;
14657 bool result;
14658 wxPyInputStream *temp1 ;
14659 bool created1 ;
14660 PyObject * obj0 = 0 ;
14661 char * kwnames[] = {
14662 (char *) "stream", NULL
14663 };
14664
14665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14666 {
14667 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14668 arg1 = temp1->m_wxis;
14669 created1 = false;
14670 } else {
14671 PyErr_Clear(); // clear the failure of the wxPyConvert above
14672 arg1 = wxPyCBInputStream_create(obj0, false);
14673 if (arg1 == NULL) {
14674 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14675 SWIG_fail;
14676 }
14677 created1 = true;
14678 }
14679 }
14680 {
14681 PyThreadState* __tstate = wxPyBeginAllowThreads();
14682 result = (bool)wxImage::CanRead(*arg1);
14683 wxPyEndAllowThreads(__tstate);
14684 if (PyErr_Occurred()) SWIG_fail;
14685 }
14686 {
14687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14688 }
14689 {
14690 if (created1) delete arg1;
14691 }
14692 return resultobj;
14693 fail:
14694 {
14695 if (created1) delete arg1;
14696 }
14697 return NULL;
14698 }
14699
14700
14701 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14702 PyObject *resultobj = 0;
14703 wxImage *arg1 = (wxImage *) 0 ;
14704 wxInputStream *arg2 = 0 ;
14705 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14706 int arg4 = (int) -1 ;
14707 bool result;
14708 void *argp1 = 0 ;
14709 int res1 = 0 ;
14710 wxPyInputStream *temp2 ;
14711 bool created2 ;
14712 long val3 ;
14713 int ecode3 = 0 ;
14714 int val4 ;
14715 int ecode4 = 0 ;
14716 PyObject * obj0 = 0 ;
14717 PyObject * obj1 = 0 ;
14718 PyObject * obj2 = 0 ;
14719 PyObject * obj3 = 0 ;
14720 char * kwnames[] = {
14721 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14722 };
14723
14724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14726 if (!SWIG_IsOK(res1)) {
14727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14728 }
14729 arg1 = reinterpret_cast< wxImage * >(argp1);
14730 {
14731 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14732 arg2 = temp2->m_wxis;
14733 created2 = false;
14734 } else {
14735 PyErr_Clear(); // clear the failure of the wxPyConvert above
14736 arg2 = wxPyCBInputStream_create(obj1, false);
14737 if (arg2 == NULL) {
14738 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14739 SWIG_fail;
14740 }
14741 created2 = true;
14742 }
14743 }
14744 if (obj2) {
14745 ecode3 = SWIG_AsVal_long(obj2, &val3);
14746 if (!SWIG_IsOK(ecode3)) {
14747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14748 }
14749 arg3 = static_cast< long >(val3);
14750 }
14751 if (obj3) {
14752 ecode4 = SWIG_AsVal_int(obj3, &val4);
14753 if (!SWIG_IsOK(ecode4)) {
14754 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14755 }
14756 arg4 = static_cast< int >(val4);
14757 }
14758 {
14759 PyThreadState* __tstate = wxPyBeginAllowThreads();
14760 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14761 wxPyEndAllowThreads(__tstate);
14762 if (PyErr_Occurred()) SWIG_fail;
14763 }
14764 {
14765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14766 }
14767 {
14768 if (created2) delete arg2;
14769 }
14770 return resultobj;
14771 fail:
14772 {
14773 if (created2) delete arg2;
14774 }
14775 return NULL;
14776 }
14777
14778
14779 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14780 PyObject *resultobj = 0;
14781 wxImage *arg1 = (wxImage *) 0 ;
14782 wxInputStream *arg2 = 0 ;
14783 wxString *arg3 = 0 ;
14784 int arg4 = (int) -1 ;
14785 bool result;
14786 void *argp1 = 0 ;
14787 int res1 = 0 ;
14788 wxPyInputStream *temp2 ;
14789 bool created2 ;
14790 bool temp3 = false ;
14791 int val4 ;
14792 int ecode4 = 0 ;
14793 PyObject * obj0 = 0 ;
14794 PyObject * obj1 = 0 ;
14795 PyObject * obj2 = 0 ;
14796 PyObject * obj3 = 0 ;
14797 char * kwnames[] = {
14798 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14799 };
14800
14801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14803 if (!SWIG_IsOK(res1)) {
14804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14805 }
14806 arg1 = reinterpret_cast< wxImage * >(argp1);
14807 {
14808 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14809 arg2 = temp2->m_wxis;
14810 created2 = false;
14811 } else {
14812 PyErr_Clear(); // clear the failure of the wxPyConvert above
14813 arg2 = wxPyCBInputStream_create(obj1, false);
14814 if (arg2 == NULL) {
14815 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14816 SWIG_fail;
14817 }
14818 created2 = true;
14819 }
14820 }
14821 {
14822 arg3 = wxString_in_helper(obj2);
14823 if (arg3 == NULL) SWIG_fail;
14824 temp3 = true;
14825 }
14826 if (obj3) {
14827 ecode4 = SWIG_AsVal_int(obj3, &val4);
14828 if (!SWIG_IsOK(ecode4)) {
14829 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14830 }
14831 arg4 = static_cast< int >(val4);
14832 }
14833 {
14834 PyThreadState* __tstate = wxPyBeginAllowThreads();
14835 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14836 wxPyEndAllowThreads(__tstate);
14837 if (PyErr_Occurred()) SWIG_fail;
14838 }
14839 {
14840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14841 }
14842 {
14843 if (created2) delete arg2;
14844 }
14845 {
14846 if (temp3)
14847 delete arg3;
14848 }
14849 return resultobj;
14850 fail:
14851 {
14852 if (created2) delete arg2;
14853 }
14854 {
14855 if (temp3)
14856 delete arg3;
14857 }
14858 return NULL;
14859 }
14860
14861
14862 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14863 PyObject *resultobj = 0;
14864 wxImage *arg1 = (wxImage *) 0 ;
14865 bool result;
14866 void *argp1 = 0 ;
14867 int res1 = 0 ;
14868 PyObject *swig_obj[1] ;
14869
14870 if (!args) SWIG_fail;
14871 swig_obj[0] = args;
14872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14873 if (!SWIG_IsOK(res1)) {
14874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14875 }
14876 arg1 = reinterpret_cast< wxImage * >(argp1);
14877 {
14878 PyThreadState* __tstate = wxPyBeginAllowThreads();
14879 result = (bool)(arg1)->Ok();
14880 wxPyEndAllowThreads(__tstate);
14881 if (PyErr_Occurred()) SWIG_fail;
14882 }
14883 {
14884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14885 }
14886 return resultobj;
14887 fail:
14888 return NULL;
14889 }
14890
14891
14892 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14893 PyObject *resultobj = 0;
14894 wxImage *arg1 = (wxImage *) 0 ;
14895 int result;
14896 void *argp1 = 0 ;
14897 int res1 = 0 ;
14898 PyObject *swig_obj[1] ;
14899
14900 if (!args) SWIG_fail;
14901 swig_obj[0] = args;
14902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14903 if (!SWIG_IsOK(res1)) {
14904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
14905 }
14906 arg1 = reinterpret_cast< wxImage * >(argp1);
14907 {
14908 PyThreadState* __tstate = wxPyBeginAllowThreads();
14909 result = (int)(arg1)->GetWidth();
14910 wxPyEndAllowThreads(__tstate);
14911 if (PyErr_Occurred()) SWIG_fail;
14912 }
14913 resultobj = SWIG_From_int(static_cast< int >(result));
14914 return resultobj;
14915 fail:
14916 return NULL;
14917 }
14918
14919
14920 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14921 PyObject *resultobj = 0;
14922 wxImage *arg1 = (wxImage *) 0 ;
14923 int result;
14924 void *argp1 = 0 ;
14925 int res1 = 0 ;
14926 PyObject *swig_obj[1] ;
14927
14928 if (!args) SWIG_fail;
14929 swig_obj[0] = args;
14930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14931 if (!SWIG_IsOK(res1)) {
14932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
14933 }
14934 arg1 = reinterpret_cast< wxImage * >(argp1);
14935 {
14936 PyThreadState* __tstate = wxPyBeginAllowThreads();
14937 result = (int)(arg1)->GetHeight();
14938 wxPyEndAllowThreads(__tstate);
14939 if (PyErr_Occurred()) SWIG_fail;
14940 }
14941 resultobj = SWIG_From_int(static_cast< int >(result));
14942 return resultobj;
14943 fail:
14944 return NULL;
14945 }
14946
14947
14948 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14949 PyObject *resultobj = 0;
14950 wxImage *arg1 = (wxImage *) 0 ;
14951 wxSize result;
14952 void *argp1 = 0 ;
14953 int res1 = 0 ;
14954 PyObject *swig_obj[1] ;
14955
14956 if (!args) SWIG_fail;
14957 swig_obj[0] = args;
14958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14959 if (!SWIG_IsOK(res1)) {
14960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
14961 }
14962 arg1 = reinterpret_cast< wxImage * >(argp1);
14963 {
14964 PyThreadState* __tstate = wxPyBeginAllowThreads();
14965 result = wxImage_GetSize(arg1);
14966 wxPyEndAllowThreads(__tstate);
14967 if (PyErr_Occurred()) SWIG_fail;
14968 }
14969 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
14970 return resultobj;
14971 fail:
14972 return NULL;
14973 }
14974
14975
14976 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14977 PyObject *resultobj = 0;
14978 wxImage *arg1 = (wxImage *) 0 ;
14979 wxRect *arg2 = 0 ;
14980 SwigValueWrapper<wxImage > result;
14981 void *argp1 = 0 ;
14982 int res1 = 0 ;
14983 wxRect temp2 ;
14984 PyObject * obj0 = 0 ;
14985 PyObject * obj1 = 0 ;
14986 char * kwnames[] = {
14987 (char *) "self",(char *) "rect", NULL
14988 };
14989
14990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
14991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14992 if (!SWIG_IsOK(res1)) {
14993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
14994 }
14995 arg1 = reinterpret_cast< wxImage * >(argp1);
14996 {
14997 arg2 = &temp2;
14998 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14999 }
15000 {
15001 PyThreadState* __tstate = wxPyBeginAllowThreads();
15002 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15003 wxPyEndAllowThreads(__tstate);
15004 if (PyErr_Occurred()) SWIG_fail;
15005 }
15006 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15007 return resultobj;
15008 fail:
15009 return NULL;
15010 }
15011
15012
15013 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15014 PyObject *resultobj = 0;
15015 wxImage *arg1 = (wxImage *) 0 ;
15016 wxSize *arg2 = 0 ;
15017 wxPoint *arg3 = 0 ;
15018 int arg4 = (int) -1 ;
15019 int arg5 = (int) -1 ;
15020 int arg6 = (int) -1 ;
15021 SwigValueWrapper<wxImage > result;
15022 void *argp1 = 0 ;
15023 int res1 = 0 ;
15024 wxSize temp2 ;
15025 wxPoint temp3 ;
15026 int val4 ;
15027 int ecode4 = 0 ;
15028 int val5 ;
15029 int ecode5 = 0 ;
15030 int val6 ;
15031 int ecode6 = 0 ;
15032 PyObject * obj0 = 0 ;
15033 PyObject * obj1 = 0 ;
15034 PyObject * obj2 = 0 ;
15035 PyObject * obj3 = 0 ;
15036 PyObject * obj4 = 0 ;
15037 PyObject * obj5 = 0 ;
15038 char * kwnames[] = {
15039 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15040 };
15041
15042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15044 if (!SWIG_IsOK(res1)) {
15045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15046 }
15047 arg1 = reinterpret_cast< wxImage * >(argp1);
15048 {
15049 arg2 = &temp2;
15050 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15051 }
15052 {
15053 arg3 = &temp3;
15054 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15055 }
15056 if (obj3) {
15057 ecode4 = SWIG_AsVal_int(obj3, &val4);
15058 if (!SWIG_IsOK(ecode4)) {
15059 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15060 }
15061 arg4 = static_cast< int >(val4);
15062 }
15063 if (obj4) {
15064 ecode5 = SWIG_AsVal_int(obj4, &val5);
15065 if (!SWIG_IsOK(ecode5)) {
15066 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15067 }
15068 arg5 = static_cast< int >(val5);
15069 }
15070 if (obj5) {
15071 ecode6 = SWIG_AsVal_int(obj5, &val6);
15072 if (!SWIG_IsOK(ecode6)) {
15073 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15074 }
15075 arg6 = static_cast< int >(val6);
15076 }
15077 {
15078 PyThreadState* __tstate = wxPyBeginAllowThreads();
15079 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15080 wxPyEndAllowThreads(__tstate);
15081 if (PyErr_Occurred()) SWIG_fail;
15082 }
15083 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15084 return resultobj;
15085 fail:
15086 return NULL;
15087 }
15088
15089
15090 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15091 PyObject *resultobj = 0;
15092 wxImage *arg1 = (wxImage *) 0 ;
15093 SwigValueWrapper<wxImage > 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_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15103 }
15104 arg1 = reinterpret_cast< wxImage * >(argp1);
15105 {
15106 PyThreadState* __tstate = wxPyBeginAllowThreads();
15107 result = (arg1)->Copy();
15108 wxPyEndAllowThreads(__tstate);
15109 if (PyErr_Occurred()) SWIG_fail;
15110 }
15111 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15112 return resultobj;
15113 fail:
15114 return NULL;
15115 }
15116
15117
15118 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15119 PyObject *resultobj = 0;
15120 wxImage *arg1 = (wxImage *) 0 ;
15121 wxImage *arg2 = 0 ;
15122 int arg3 ;
15123 int arg4 ;
15124 void *argp1 = 0 ;
15125 int res1 = 0 ;
15126 void *argp2 = 0 ;
15127 int res2 = 0 ;
15128 int val3 ;
15129 int ecode3 = 0 ;
15130 int val4 ;
15131 int ecode4 = 0 ;
15132 PyObject * obj0 = 0 ;
15133 PyObject * obj1 = 0 ;
15134 PyObject * obj2 = 0 ;
15135 PyObject * obj3 = 0 ;
15136 char * kwnames[] = {
15137 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15138 };
15139
15140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15142 if (!SWIG_IsOK(res1)) {
15143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15144 }
15145 arg1 = reinterpret_cast< wxImage * >(argp1);
15146 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15147 if (!SWIG_IsOK(res2)) {
15148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15149 }
15150 if (!argp2) {
15151 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15152 }
15153 arg2 = reinterpret_cast< wxImage * >(argp2);
15154 ecode3 = SWIG_AsVal_int(obj2, &val3);
15155 if (!SWIG_IsOK(ecode3)) {
15156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15157 }
15158 arg3 = static_cast< int >(val3);
15159 ecode4 = SWIG_AsVal_int(obj3, &val4);
15160 if (!SWIG_IsOK(ecode4)) {
15161 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15162 }
15163 arg4 = static_cast< int >(val4);
15164 {
15165 PyThreadState* __tstate = wxPyBeginAllowThreads();
15166 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15167 wxPyEndAllowThreads(__tstate);
15168 if (PyErr_Occurred()) SWIG_fail;
15169 }
15170 resultobj = SWIG_Py_Void();
15171 return resultobj;
15172 fail:
15173 return NULL;
15174 }
15175
15176
15177 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15178 PyObject *resultobj = 0;
15179 wxImage *arg1 = (wxImage *) 0 ;
15180 PyObject *result = 0 ;
15181 void *argp1 = 0 ;
15182 int res1 = 0 ;
15183 PyObject *swig_obj[1] ;
15184
15185 if (!args) SWIG_fail;
15186 swig_obj[0] = args;
15187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15188 if (!SWIG_IsOK(res1)) {
15189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15190 }
15191 arg1 = reinterpret_cast< wxImage * >(argp1);
15192 {
15193 PyThreadState* __tstate = wxPyBeginAllowThreads();
15194 result = (PyObject *)wxImage_GetData(arg1);
15195 wxPyEndAllowThreads(__tstate);
15196 if (PyErr_Occurred()) SWIG_fail;
15197 }
15198 resultobj = result;
15199 return resultobj;
15200 fail:
15201 return NULL;
15202 }
15203
15204
15205 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15206 PyObject *resultobj = 0;
15207 wxImage *arg1 = (wxImage *) 0 ;
15208 buffer arg2 ;
15209 int arg3 ;
15210 void *argp1 = 0 ;
15211 int res1 = 0 ;
15212 PyObject * obj0 = 0 ;
15213 PyObject * obj1 = 0 ;
15214 char * kwnames[] = {
15215 (char *) "self",(char *) "data", NULL
15216 };
15217
15218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15220 if (!SWIG_IsOK(res1)) {
15221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15222 }
15223 arg1 = reinterpret_cast< wxImage * >(argp1);
15224 {
15225 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15226 }
15227 {
15228 PyThreadState* __tstate = wxPyBeginAllowThreads();
15229 wxImage_SetData(arg1,arg2,arg3);
15230 wxPyEndAllowThreads(__tstate);
15231 if (PyErr_Occurred()) SWIG_fail;
15232 }
15233 resultobj = SWIG_Py_Void();
15234 return resultobj;
15235 fail:
15236 return NULL;
15237 }
15238
15239
15240 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15241 PyObject *resultobj = 0;
15242 wxImage *arg1 = (wxImage *) 0 ;
15243 PyObject *result = 0 ;
15244 void *argp1 = 0 ;
15245 int res1 = 0 ;
15246 PyObject *swig_obj[1] ;
15247
15248 if (!args) SWIG_fail;
15249 swig_obj[0] = args;
15250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15251 if (!SWIG_IsOK(res1)) {
15252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15253 }
15254 arg1 = reinterpret_cast< wxImage * >(argp1);
15255 {
15256 PyThreadState* __tstate = wxPyBeginAllowThreads();
15257 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15258 wxPyEndAllowThreads(__tstate);
15259 if (PyErr_Occurred()) SWIG_fail;
15260 }
15261 resultobj = result;
15262 return resultobj;
15263 fail:
15264 return NULL;
15265 }
15266
15267
15268 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15269 PyObject *resultobj = 0;
15270 wxImage *arg1 = (wxImage *) 0 ;
15271 buffer arg2 ;
15272 int arg3 ;
15273 void *argp1 = 0 ;
15274 int res1 = 0 ;
15275 PyObject * obj0 = 0 ;
15276 PyObject * obj1 = 0 ;
15277 char * kwnames[] = {
15278 (char *) "self",(char *) "data", NULL
15279 };
15280
15281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15283 if (!SWIG_IsOK(res1)) {
15284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15285 }
15286 arg1 = reinterpret_cast< wxImage * >(argp1);
15287 {
15288 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15289 }
15290 {
15291 PyThreadState* __tstate = wxPyBeginAllowThreads();
15292 wxImage_SetDataBuffer(arg1,arg2,arg3);
15293 wxPyEndAllowThreads(__tstate);
15294 if (PyErr_Occurred()) SWIG_fail;
15295 }
15296 resultobj = SWIG_Py_Void();
15297 return resultobj;
15298 fail:
15299 return NULL;
15300 }
15301
15302
15303 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15304 PyObject *resultobj = 0;
15305 wxImage *arg1 = (wxImage *) 0 ;
15306 PyObject *result = 0 ;
15307 void *argp1 = 0 ;
15308 int res1 = 0 ;
15309 PyObject *swig_obj[1] ;
15310
15311 if (!args) SWIG_fail;
15312 swig_obj[0] = args;
15313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15314 if (!SWIG_IsOK(res1)) {
15315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15316 }
15317 arg1 = reinterpret_cast< wxImage * >(argp1);
15318 {
15319 PyThreadState* __tstate = wxPyBeginAllowThreads();
15320 result = (PyObject *)wxImage_GetAlphaData(arg1);
15321 wxPyEndAllowThreads(__tstate);
15322 if (PyErr_Occurred()) SWIG_fail;
15323 }
15324 resultobj = result;
15325 return resultobj;
15326 fail:
15327 return NULL;
15328 }
15329
15330
15331 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15332 PyObject *resultobj = 0;
15333 wxImage *arg1 = (wxImage *) 0 ;
15334 buffer arg2 ;
15335 int arg3 ;
15336 void *argp1 = 0 ;
15337 int res1 = 0 ;
15338 PyObject * obj0 = 0 ;
15339 PyObject * obj1 = 0 ;
15340 char * kwnames[] = {
15341 (char *) "self",(char *) "alpha", NULL
15342 };
15343
15344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15346 if (!SWIG_IsOK(res1)) {
15347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15348 }
15349 arg1 = reinterpret_cast< wxImage * >(argp1);
15350 {
15351 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15352 }
15353 {
15354 PyThreadState* __tstate = wxPyBeginAllowThreads();
15355 wxImage_SetAlphaData(arg1,arg2,arg3);
15356 wxPyEndAllowThreads(__tstate);
15357 if (PyErr_Occurred()) SWIG_fail;
15358 }
15359 resultobj = SWIG_Py_Void();
15360 return resultobj;
15361 fail:
15362 return NULL;
15363 }
15364
15365
15366 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15367 PyObject *resultobj = 0;
15368 wxImage *arg1 = (wxImage *) 0 ;
15369 PyObject *result = 0 ;
15370 void *argp1 = 0 ;
15371 int res1 = 0 ;
15372 PyObject *swig_obj[1] ;
15373
15374 if (!args) SWIG_fail;
15375 swig_obj[0] = args;
15376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15377 if (!SWIG_IsOK(res1)) {
15378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15379 }
15380 arg1 = reinterpret_cast< wxImage * >(argp1);
15381 {
15382 PyThreadState* __tstate = wxPyBeginAllowThreads();
15383 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15384 wxPyEndAllowThreads(__tstate);
15385 if (PyErr_Occurred()) SWIG_fail;
15386 }
15387 resultobj = result;
15388 return resultobj;
15389 fail:
15390 return NULL;
15391 }
15392
15393
15394 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15395 PyObject *resultobj = 0;
15396 wxImage *arg1 = (wxImage *) 0 ;
15397 buffer arg2 ;
15398 int arg3 ;
15399 void *argp1 = 0 ;
15400 int res1 = 0 ;
15401 PyObject * obj0 = 0 ;
15402 PyObject * obj1 = 0 ;
15403 char * kwnames[] = {
15404 (char *) "self",(char *) "alpha", NULL
15405 };
15406
15407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15409 if (!SWIG_IsOK(res1)) {
15410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15411 }
15412 arg1 = reinterpret_cast< wxImage * >(argp1);
15413 {
15414 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15415 }
15416 {
15417 PyThreadState* __tstate = wxPyBeginAllowThreads();
15418 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15419 wxPyEndAllowThreads(__tstate);
15420 if (PyErr_Occurred()) SWIG_fail;
15421 }
15422 resultobj = SWIG_Py_Void();
15423 return resultobj;
15424 fail:
15425 return NULL;
15426 }
15427
15428
15429 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15430 PyObject *resultobj = 0;
15431 wxImage *arg1 = (wxImage *) 0 ;
15432 byte arg2 ;
15433 byte arg3 ;
15434 byte arg4 ;
15435 void *argp1 = 0 ;
15436 int res1 = 0 ;
15437 unsigned char val2 ;
15438 int ecode2 = 0 ;
15439 unsigned char val3 ;
15440 int ecode3 = 0 ;
15441 unsigned char val4 ;
15442 int ecode4 = 0 ;
15443 PyObject * obj0 = 0 ;
15444 PyObject * obj1 = 0 ;
15445 PyObject * obj2 = 0 ;
15446 PyObject * obj3 = 0 ;
15447 char * kwnames[] = {
15448 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15449 };
15450
15451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15455 }
15456 arg1 = reinterpret_cast< wxImage * >(argp1);
15457 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15458 if (!SWIG_IsOK(ecode2)) {
15459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15460 }
15461 arg2 = static_cast< byte >(val2);
15462 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15463 if (!SWIG_IsOK(ecode3)) {
15464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15465 }
15466 arg3 = static_cast< byte >(val3);
15467 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15468 if (!SWIG_IsOK(ecode4)) {
15469 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15470 }
15471 arg4 = static_cast< byte >(val4);
15472 {
15473 PyThreadState* __tstate = wxPyBeginAllowThreads();
15474 (arg1)->SetMaskColour(arg2,arg3,arg4);
15475 wxPyEndAllowThreads(__tstate);
15476 if (PyErr_Occurred()) SWIG_fail;
15477 }
15478 resultobj = SWIG_Py_Void();
15479 return resultobj;
15480 fail:
15481 return NULL;
15482 }
15483
15484
15485 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15486 PyObject *resultobj = 0;
15487 wxImage *arg1 = (wxImage *) 0 ;
15488 byte *arg2 = (byte *) 0 ;
15489 byte *arg3 = (byte *) 0 ;
15490 byte *arg4 = (byte *) 0 ;
15491 void *argp1 = 0 ;
15492 int res1 = 0 ;
15493 byte temp2 ;
15494 int res2 = SWIG_TMPOBJ ;
15495 byte temp3 ;
15496 int res3 = SWIG_TMPOBJ ;
15497 byte temp4 ;
15498 int res4 = SWIG_TMPOBJ ;
15499 PyObject *swig_obj[1] ;
15500
15501 arg2 = &temp2;
15502 arg3 = &temp3;
15503 arg4 = &temp4;
15504 if (!args) SWIG_fail;
15505 swig_obj[0] = args;
15506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15507 if (!SWIG_IsOK(res1)) {
15508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15509 }
15510 arg1 = reinterpret_cast< wxImage * >(argp1);
15511 {
15512 PyThreadState* __tstate = wxPyBeginAllowThreads();
15513 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15514 wxPyEndAllowThreads(__tstate);
15515 if (PyErr_Occurred()) SWIG_fail;
15516 }
15517 resultobj = SWIG_Py_Void();
15518 if (SWIG_IsTmpObj(res2)) {
15519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15520 } else {
15521 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15522 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15523 }
15524 if (SWIG_IsTmpObj(res3)) {
15525 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15526 } else {
15527 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15528 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15529 }
15530 if (SWIG_IsTmpObj(res4)) {
15531 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15532 } else {
15533 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15534 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15535 }
15536 return resultobj;
15537 fail:
15538 return NULL;
15539 }
15540
15541
15542 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15543 PyObject *resultobj = 0;
15544 wxImage *arg1 = (wxImage *) 0 ;
15545 byte result;
15546 void *argp1 = 0 ;
15547 int res1 = 0 ;
15548 PyObject *swig_obj[1] ;
15549
15550 if (!args) SWIG_fail;
15551 swig_obj[0] = args;
15552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15553 if (!SWIG_IsOK(res1)) {
15554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15555 }
15556 arg1 = reinterpret_cast< wxImage * >(argp1);
15557 {
15558 PyThreadState* __tstate = wxPyBeginAllowThreads();
15559 result = (byte)(arg1)->GetMaskRed();
15560 wxPyEndAllowThreads(__tstate);
15561 if (PyErr_Occurred()) SWIG_fail;
15562 }
15563 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15564 return resultobj;
15565 fail:
15566 return NULL;
15567 }
15568
15569
15570 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15571 PyObject *resultobj = 0;
15572 wxImage *arg1 = (wxImage *) 0 ;
15573 byte result;
15574 void *argp1 = 0 ;
15575 int res1 = 0 ;
15576 PyObject *swig_obj[1] ;
15577
15578 if (!args) SWIG_fail;
15579 swig_obj[0] = args;
15580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15581 if (!SWIG_IsOK(res1)) {
15582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15583 }
15584 arg1 = reinterpret_cast< wxImage * >(argp1);
15585 {
15586 PyThreadState* __tstate = wxPyBeginAllowThreads();
15587 result = (byte)(arg1)->GetMaskGreen();
15588 wxPyEndAllowThreads(__tstate);
15589 if (PyErr_Occurred()) SWIG_fail;
15590 }
15591 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15592 return resultobj;
15593 fail:
15594 return NULL;
15595 }
15596
15597
15598 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15599 PyObject *resultobj = 0;
15600 wxImage *arg1 = (wxImage *) 0 ;
15601 byte result;
15602 void *argp1 = 0 ;
15603 int res1 = 0 ;
15604 PyObject *swig_obj[1] ;
15605
15606 if (!args) SWIG_fail;
15607 swig_obj[0] = args;
15608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15609 if (!SWIG_IsOK(res1)) {
15610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15611 }
15612 arg1 = reinterpret_cast< wxImage * >(argp1);
15613 {
15614 PyThreadState* __tstate = wxPyBeginAllowThreads();
15615 result = (byte)(arg1)->GetMaskBlue();
15616 wxPyEndAllowThreads(__tstate);
15617 if (PyErr_Occurred()) SWIG_fail;
15618 }
15619 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15620 return resultobj;
15621 fail:
15622 return NULL;
15623 }
15624
15625
15626 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15627 PyObject *resultobj = 0;
15628 wxImage *arg1 = (wxImage *) 0 ;
15629 bool arg2 = (bool) true ;
15630 void *argp1 = 0 ;
15631 int res1 = 0 ;
15632 bool val2 ;
15633 int ecode2 = 0 ;
15634 PyObject * obj0 = 0 ;
15635 PyObject * obj1 = 0 ;
15636 char * kwnames[] = {
15637 (char *) "self",(char *) "mask", NULL
15638 };
15639
15640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15642 if (!SWIG_IsOK(res1)) {
15643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15644 }
15645 arg1 = reinterpret_cast< wxImage * >(argp1);
15646 if (obj1) {
15647 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15648 if (!SWIG_IsOK(ecode2)) {
15649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15650 }
15651 arg2 = static_cast< bool >(val2);
15652 }
15653 {
15654 PyThreadState* __tstate = wxPyBeginAllowThreads();
15655 (arg1)->SetMask(arg2);
15656 wxPyEndAllowThreads(__tstate);
15657 if (PyErr_Occurred()) SWIG_fail;
15658 }
15659 resultobj = SWIG_Py_Void();
15660 return resultobj;
15661 fail:
15662 return NULL;
15663 }
15664
15665
15666 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15667 PyObject *resultobj = 0;
15668 wxImage *arg1 = (wxImage *) 0 ;
15669 bool result;
15670 void *argp1 = 0 ;
15671 int res1 = 0 ;
15672 PyObject *swig_obj[1] ;
15673
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_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15679 }
15680 arg1 = reinterpret_cast< wxImage * >(argp1);
15681 {
15682 PyThreadState* __tstate = wxPyBeginAllowThreads();
15683 result = (bool)(arg1)->HasMask();
15684 wxPyEndAllowThreads(__tstate);
15685 if (PyErr_Occurred()) SWIG_fail;
15686 }
15687 {
15688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15689 }
15690 return resultobj;
15691 fail:
15692 return NULL;
15693 }
15694
15695
15696 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15697 PyObject *resultobj = 0;
15698 wxImage *arg1 = (wxImage *) 0 ;
15699 double arg2 ;
15700 wxPoint *arg3 = 0 ;
15701 bool arg4 = (bool) true ;
15702 wxPoint *arg5 = (wxPoint *) NULL ;
15703 SwigValueWrapper<wxImage > result;
15704 void *argp1 = 0 ;
15705 int res1 = 0 ;
15706 double val2 ;
15707 int ecode2 = 0 ;
15708 wxPoint temp3 ;
15709 bool val4 ;
15710 int ecode4 = 0 ;
15711 void *argp5 = 0 ;
15712 int res5 = 0 ;
15713 PyObject * obj0 = 0 ;
15714 PyObject * obj1 = 0 ;
15715 PyObject * obj2 = 0 ;
15716 PyObject * obj3 = 0 ;
15717 PyObject * obj4 = 0 ;
15718 char * kwnames[] = {
15719 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15720 };
15721
15722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15724 if (!SWIG_IsOK(res1)) {
15725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15726 }
15727 arg1 = reinterpret_cast< wxImage * >(argp1);
15728 ecode2 = SWIG_AsVal_double(obj1, &val2);
15729 if (!SWIG_IsOK(ecode2)) {
15730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15731 }
15732 arg2 = static_cast< double >(val2);
15733 {
15734 arg3 = &temp3;
15735 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15736 }
15737 if (obj3) {
15738 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15739 if (!SWIG_IsOK(ecode4)) {
15740 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15741 }
15742 arg4 = static_cast< bool >(val4);
15743 }
15744 if (obj4) {
15745 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15746 if (!SWIG_IsOK(res5)) {
15747 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15748 }
15749 arg5 = reinterpret_cast< wxPoint * >(argp5);
15750 }
15751 {
15752 PyThreadState* __tstate = wxPyBeginAllowThreads();
15753 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15754 wxPyEndAllowThreads(__tstate);
15755 if (PyErr_Occurred()) SWIG_fail;
15756 }
15757 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15758 return resultobj;
15759 fail:
15760 return NULL;
15761 }
15762
15763
15764 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15765 PyObject *resultobj = 0;
15766 wxImage *arg1 = (wxImage *) 0 ;
15767 bool arg2 = (bool) true ;
15768 SwigValueWrapper<wxImage > result;
15769 void *argp1 = 0 ;
15770 int res1 = 0 ;
15771 bool val2 ;
15772 int ecode2 = 0 ;
15773 PyObject * obj0 = 0 ;
15774 PyObject * obj1 = 0 ;
15775 char * kwnames[] = {
15776 (char *) "self",(char *) "clockwise", NULL
15777 };
15778
15779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15781 if (!SWIG_IsOK(res1)) {
15782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15783 }
15784 arg1 = reinterpret_cast< wxImage * >(argp1);
15785 if (obj1) {
15786 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15787 if (!SWIG_IsOK(ecode2)) {
15788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15789 }
15790 arg2 = static_cast< bool >(val2);
15791 }
15792 {
15793 PyThreadState* __tstate = wxPyBeginAllowThreads();
15794 result = (arg1)->Rotate90(arg2);
15795 wxPyEndAllowThreads(__tstate);
15796 if (PyErr_Occurred()) SWIG_fail;
15797 }
15798 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15799 return resultobj;
15800 fail:
15801 return NULL;
15802 }
15803
15804
15805 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15806 PyObject *resultobj = 0;
15807 wxImage *arg1 = (wxImage *) 0 ;
15808 bool arg2 = (bool) true ;
15809 SwigValueWrapper<wxImage > result;
15810 void *argp1 = 0 ;
15811 int res1 = 0 ;
15812 bool val2 ;
15813 int ecode2 = 0 ;
15814 PyObject * obj0 = 0 ;
15815 PyObject * obj1 = 0 ;
15816 char * kwnames[] = {
15817 (char *) "self",(char *) "horizontally", NULL
15818 };
15819
15820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15822 if (!SWIG_IsOK(res1)) {
15823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15824 }
15825 arg1 = reinterpret_cast< wxImage * >(argp1);
15826 if (obj1) {
15827 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15828 if (!SWIG_IsOK(ecode2)) {
15829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15830 }
15831 arg2 = static_cast< bool >(val2);
15832 }
15833 {
15834 PyThreadState* __tstate = wxPyBeginAllowThreads();
15835 result = (arg1)->Mirror(arg2);
15836 wxPyEndAllowThreads(__tstate);
15837 if (PyErr_Occurred()) SWIG_fail;
15838 }
15839 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15840 return resultobj;
15841 fail:
15842 return NULL;
15843 }
15844
15845
15846 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15847 PyObject *resultobj = 0;
15848 wxImage *arg1 = (wxImage *) 0 ;
15849 byte arg2 ;
15850 byte arg3 ;
15851 byte arg4 ;
15852 byte arg5 ;
15853 byte arg6 ;
15854 byte arg7 ;
15855 void *argp1 = 0 ;
15856 int res1 = 0 ;
15857 unsigned char val2 ;
15858 int ecode2 = 0 ;
15859 unsigned char val3 ;
15860 int ecode3 = 0 ;
15861 unsigned char val4 ;
15862 int ecode4 = 0 ;
15863 unsigned char val5 ;
15864 int ecode5 = 0 ;
15865 unsigned char val6 ;
15866 int ecode6 = 0 ;
15867 unsigned char val7 ;
15868 int ecode7 = 0 ;
15869 PyObject * obj0 = 0 ;
15870 PyObject * obj1 = 0 ;
15871 PyObject * obj2 = 0 ;
15872 PyObject * obj3 = 0 ;
15873 PyObject * obj4 = 0 ;
15874 PyObject * obj5 = 0 ;
15875 PyObject * obj6 = 0 ;
15876 char * kwnames[] = {
15877 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15878 };
15879
15880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15882 if (!SWIG_IsOK(res1)) {
15883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15884 }
15885 arg1 = reinterpret_cast< wxImage * >(argp1);
15886 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15887 if (!SWIG_IsOK(ecode2)) {
15888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15889 }
15890 arg2 = static_cast< byte >(val2);
15891 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15892 if (!SWIG_IsOK(ecode3)) {
15893 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
15894 }
15895 arg3 = static_cast< byte >(val3);
15896 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15897 if (!SWIG_IsOK(ecode4)) {
15898 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
15899 }
15900 arg4 = static_cast< byte >(val4);
15901 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15902 if (!SWIG_IsOK(ecode5)) {
15903 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
15904 }
15905 arg5 = static_cast< byte >(val5);
15906 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
15907 if (!SWIG_IsOK(ecode6)) {
15908 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
15909 }
15910 arg6 = static_cast< byte >(val6);
15911 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
15912 if (!SWIG_IsOK(ecode7)) {
15913 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
15914 }
15915 arg7 = static_cast< byte >(val7);
15916 {
15917 PyThreadState* __tstate = wxPyBeginAllowThreads();
15918 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
15919 wxPyEndAllowThreads(__tstate);
15920 if (PyErr_Occurred()) SWIG_fail;
15921 }
15922 resultobj = SWIG_Py_Void();
15923 return resultobj;
15924 fail:
15925 return NULL;
15926 }
15927
15928
15929 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15930 PyObject *resultobj = 0;
15931 wxImage *arg1 = (wxImage *) 0 ;
15932 double arg2 = (double) 0.299 ;
15933 double arg3 = (double) 0.587 ;
15934 double arg4 = (double) 0.114 ;
15935 SwigValueWrapper<wxImage > result;
15936 void *argp1 = 0 ;
15937 int res1 = 0 ;
15938 double val2 ;
15939 int ecode2 = 0 ;
15940 double val3 ;
15941 int ecode3 = 0 ;
15942 double val4 ;
15943 int ecode4 = 0 ;
15944 PyObject * obj0 = 0 ;
15945 PyObject * obj1 = 0 ;
15946 PyObject * obj2 = 0 ;
15947 PyObject * obj3 = 0 ;
15948 char * kwnames[] = {
15949 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
15950 };
15951
15952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15954 if (!SWIG_IsOK(res1)) {
15955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
15956 }
15957 arg1 = reinterpret_cast< wxImage * >(argp1);
15958 if (obj1) {
15959 ecode2 = SWIG_AsVal_double(obj1, &val2);
15960 if (!SWIG_IsOK(ecode2)) {
15961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
15962 }
15963 arg2 = static_cast< double >(val2);
15964 }
15965 if (obj2) {
15966 ecode3 = SWIG_AsVal_double(obj2, &val3);
15967 if (!SWIG_IsOK(ecode3)) {
15968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
15969 }
15970 arg3 = static_cast< double >(val3);
15971 }
15972 if (obj3) {
15973 ecode4 = SWIG_AsVal_double(obj3, &val4);
15974 if (!SWIG_IsOK(ecode4)) {
15975 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
15976 }
15977 arg4 = static_cast< double >(val4);
15978 }
15979 {
15980 PyThreadState* __tstate = wxPyBeginAllowThreads();
15981 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
15982 wxPyEndAllowThreads(__tstate);
15983 if (PyErr_Occurred()) SWIG_fail;
15984 }
15985 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15986 return resultobj;
15987 fail:
15988 return NULL;
15989 }
15990
15991
15992 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15993 PyObject *resultobj = 0;
15994 wxImage *arg1 = (wxImage *) 0 ;
15995 byte arg2 ;
15996 byte arg3 ;
15997 byte arg4 ;
15998 SwigValueWrapper<wxImage > result;
15999 void *argp1 = 0 ;
16000 int res1 = 0 ;
16001 unsigned char val2 ;
16002 int ecode2 = 0 ;
16003 unsigned char val3 ;
16004 int ecode3 = 0 ;
16005 unsigned char val4 ;
16006 int ecode4 = 0 ;
16007 PyObject * obj0 = 0 ;
16008 PyObject * obj1 = 0 ;
16009 PyObject * obj2 = 0 ;
16010 PyObject * obj3 = 0 ;
16011 char * kwnames[] = {
16012 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16013 };
16014
16015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16017 if (!SWIG_IsOK(res1)) {
16018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16019 }
16020 arg1 = reinterpret_cast< wxImage * >(argp1);
16021 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16022 if (!SWIG_IsOK(ecode2)) {
16023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16024 }
16025 arg2 = static_cast< byte >(val2);
16026 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16027 if (!SWIG_IsOK(ecode3)) {
16028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16029 }
16030 arg3 = static_cast< byte >(val3);
16031 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16032 if (!SWIG_IsOK(ecode4)) {
16033 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16034 }
16035 arg4 = static_cast< byte >(val4);
16036 {
16037 PyThreadState* __tstate = wxPyBeginAllowThreads();
16038 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16039 wxPyEndAllowThreads(__tstate);
16040 if (PyErr_Occurred()) SWIG_fail;
16041 }
16042 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16043 return resultobj;
16044 fail:
16045 return NULL;
16046 }
16047
16048
16049 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16050 PyObject *resultobj = 0;
16051 wxImage *arg1 = (wxImage *) 0 ;
16052 wxString *arg2 = 0 ;
16053 wxString *arg3 = 0 ;
16054 void *argp1 = 0 ;
16055 int res1 = 0 ;
16056 bool temp2 = false ;
16057 bool temp3 = false ;
16058 PyObject * obj0 = 0 ;
16059 PyObject * obj1 = 0 ;
16060 PyObject * obj2 = 0 ;
16061 char * kwnames[] = {
16062 (char *) "self",(char *) "name",(char *) "value", NULL
16063 };
16064
16065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16067 if (!SWIG_IsOK(res1)) {
16068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16069 }
16070 arg1 = reinterpret_cast< wxImage * >(argp1);
16071 {
16072 arg2 = wxString_in_helper(obj1);
16073 if (arg2 == NULL) SWIG_fail;
16074 temp2 = true;
16075 }
16076 {
16077 arg3 = wxString_in_helper(obj2);
16078 if (arg3 == NULL) SWIG_fail;
16079 temp3 = true;
16080 }
16081 {
16082 PyThreadState* __tstate = wxPyBeginAllowThreads();
16083 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16084 wxPyEndAllowThreads(__tstate);
16085 if (PyErr_Occurred()) SWIG_fail;
16086 }
16087 resultobj = SWIG_Py_Void();
16088 {
16089 if (temp2)
16090 delete arg2;
16091 }
16092 {
16093 if (temp3)
16094 delete arg3;
16095 }
16096 return resultobj;
16097 fail:
16098 {
16099 if (temp2)
16100 delete arg2;
16101 }
16102 {
16103 if (temp3)
16104 delete arg3;
16105 }
16106 return NULL;
16107 }
16108
16109
16110 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16111 PyObject *resultobj = 0;
16112 wxImage *arg1 = (wxImage *) 0 ;
16113 wxString *arg2 = 0 ;
16114 int arg3 ;
16115 void *argp1 = 0 ;
16116 int res1 = 0 ;
16117 bool temp2 = false ;
16118 int val3 ;
16119 int ecode3 = 0 ;
16120 PyObject * obj0 = 0 ;
16121 PyObject * obj1 = 0 ;
16122 PyObject * obj2 = 0 ;
16123 char * kwnames[] = {
16124 (char *) "self",(char *) "name",(char *) "value", NULL
16125 };
16126
16127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16129 if (!SWIG_IsOK(res1)) {
16130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16131 }
16132 arg1 = reinterpret_cast< wxImage * >(argp1);
16133 {
16134 arg2 = wxString_in_helper(obj1);
16135 if (arg2 == NULL) SWIG_fail;
16136 temp2 = true;
16137 }
16138 ecode3 = SWIG_AsVal_int(obj2, &val3);
16139 if (!SWIG_IsOK(ecode3)) {
16140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16141 }
16142 arg3 = static_cast< int >(val3);
16143 {
16144 PyThreadState* __tstate = wxPyBeginAllowThreads();
16145 (arg1)->SetOption((wxString const &)*arg2,arg3);
16146 wxPyEndAllowThreads(__tstate);
16147 if (PyErr_Occurred()) SWIG_fail;
16148 }
16149 resultobj = SWIG_Py_Void();
16150 {
16151 if (temp2)
16152 delete arg2;
16153 }
16154 return resultobj;
16155 fail:
16156 {
16157 if (temp2)
16158 delete arg2;
16159 }
16160 return NULL;
16161 }
16162
16163
16164 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16165 PyObject *resultobj = 0;
16166 wxImage *arg1 = (wxImage *) 0 ;
16167 wxString *arg2 = 0 ;
16168 wxString result;
16169 void *argp1 = 0 ;
16170 int res1 = 0 ;
16171 bool temp2 = false ;
16172 PyObject * obj0 = 0 ;
16173 PyObject * obj1 = 0 ;
16174 char * kwnames[] = {
16175 (char *) "self",(char *) "name", NULL
16176 };
16177
16178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16180 if (!SWIG_IsOK(res1)) {
16181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16182 }
16183 arg1 = reinterpret_cast< wxImage * >(argp1);
16184 {
16185 arg2 = wxString_in_helper(obj1);
16186 if (arg2 == NULL) SWIG_fail;
16187 temp2 = true;
16188 }
16189 {
16190 PyThreadState* __tstate = wxPyBeginAllowThreads();
16191 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16192 wxPyEndAllowThreads(__tstate);
16193 if (PyErr_Occurred()) SWIG_fail;
16194 }
16195 {
16196 #if wxUSE_UNICODE
16197 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16198 #else
16199 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16200 #endif
16201 }
16202 {
16203 if (temp2)
16204 delete arg2;
16205 }
16206 return resultobj;
16207 fail:
16208 {
16209 if (temp2)
16210 delete arg2;
16211 }
16212 return NULL;
16213 }
16214
16215
16216 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16217 PyObject *resultobj = 0;
16218 wxImage *arg1 = (wxImage *) 0 ;
16219 wxString *arg2 = 0 ;
16220 int result;
16221 void *argp1 = 0 ;
16222 int res1 = 0 ;
16223 bool temp2 = false ;
16224 PyObject * obj0 = 0 ;
16225 PyObject * obj1 = 0 ;
16226 char * kwnames[] = {
16227 (char *) "self",(char *) "name", NULL
16228 };
16229
16230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16232 if (!SWIG_IsOK(res1)) {
16233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16234 }
16235 arg1 = reinterpret_cast< wxImage * >(argp1);
16236 {
16237 arg2 = wxString_in_helper(obj1);
16238 if (arg2 == NULL) SWIG_fail;
16239 temp2 = true;
16240 }
16241 {
16242 PyThreadState* __tstate = wxPyBeginAllowThreads();
16243 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16244 wxPyEndAllowThreads(__tstate);
16245 if (PyErr_Occurred()) SWIG_fail;
16246 }
16247 resultobj = SWIG_From_int(static_cast< int >(result));
16248 {
16249 if (temp2)
16250 delete arg2;
16251 }
16252 return resultobj;
16253 fail:
16254 {
16255 if (temp2)
16256 delete arg2;
16257 }
16258 return NULL;
16259 }
16260
16261
16262 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16263 PyObject *resultobj = 0;
16264 wxImage *arg1 = (wxImage *) 0 ;
16265 wxString *arg2 = 0 ;
16266 bool result;
16267 void *argp1 = 0 ;
16268 int res1 = 0 ;
16269 bool temp2 = false ;
16270 PyObject * obj0 = 0 ;
16271 PyObject * obj1 = 0 ;
16272 char * kwnames[] = {
16273 (char *) "self",(char *) "name", NULL
16274 };
16275
16276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16278 if (!SWIG_IsOK(res1)) {
16279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16280 }
16281 arg1 = reinterpret_cast< wxImage * >(argp1);
16282 {
16283 arg2 = wxString_in_helper(obj1);
16284 if (arg2 == NULL) SWIG_fail;
16285 temp2 = true;
16286 }
16287 {
16288 PyThreadState* __tstate = wxPyBeginAllowThreads();
16289 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16290 wxPyEndAllowThreads(__tstate);
16291 if (PyErr_Occurred()) SWIG_fail;
16292 }
16293 {
16294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16295 }
16296 {
16297 if (temp2)
16298 delete arg2;
16299 }
16300 return resultobj;
16301 fail:
16302 {
16303 if (temp2)
16304 delete arg2;
16305 }
16306 return NULL;
16307 }
16308
16309
16310 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16311 PyObject *resultobj = 0;
16312 wxImage *arg1 = (wxImage *) 0 ;
16313 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16314 unsigned long result;
16315 void *argp1 = 0 ;
16316 int res1 = 0 ;
16317 unsigned long val2 ;
16318 int ecode2 = 0 ;
16319 PyObject * obj0 = 0 ;
16320 PyObject * obj1 = 0 ;
16321 char * kwnames[] = {
16322 (char *) "self",(char *) "stopafter", NULL
16323 };
16324
16325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16327 if (!SWIG_IsOK(res1)) {
16328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16329 }
16330 arg1 = reinterpret_cast< wxImage * >(argp1);
16331 if (obj1) {
16332 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16333 if (!SWIG_IsOK(ecode2)) {
16334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16335 }
16336 arg2 = static_cast< unsigned long >(val2);
16337 }
16338 {
16339 PyThreadState* __tstate = wxPyBeginAllowThreads();
16340 result = (unsigned long)(arg1)->CountColours(arg2);
16341 wxPyEndAllowThreads(__tstate);
16342 if (PyErr_Occurred()) SWIG_fail;
16343 }
16344 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16345 return resultobj;
16346 fail:
16347 return NULL;
16348 }
16349
16350
16351 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16352 PyObject *resultobj = 0;
16353 wxImage *arg1 = (wxImage *) 0 ;
16354 wxImageHistogram *arg2 = 0 ;
16355 unsigned long result;
16356 void *argp1 = 0 ;
16357 int res1 = 0 ;
16358 void *argp2 = 0 ;
16359 int res2 = 0 ;
16360 PyObject * obj0 = 0 ;
16361 PyObject * obj1 = 0 ;
16362 char * kwnames[] = {
16363 (char *) "self",(char *) "h", NULL
16364 };
16365
16366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16368 if (!SWIG_IsOK(res1)) {
16369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16370 }
16371 arg1 = reinterpret_cast< wxImage * >(argp1);
16372 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16373 if (!SWIG_IsOK(res2)) {
16374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16375 }
16376 if (!argp2) {
16377 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16378 }
16379 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16380 {
16381 PyThreadState* __tstate = wxPyBeginAllowThreads();
16382 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16383 wxPyEndAllowThreads(__tstate);
16384 if (PyErr_Occurred()) SWIG_fail;
16385 }
16386 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16387 return resultobj;
16388 fail:
16389 return NULL;
16390 }
16391
16392
16393 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16394 PyObject *resultobj = 0;
16395 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16396 void *argp1 = 0 ;
16397 int res1 = 0 ;
16398 PyObject * obj0 = 0 ;
16399 char * kwnames[] = {
16400 (char *) "handler", NULL
16401 };
16402
16403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16405 if (!SWIG_IsOK(res1)) {
16406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16407 }
16408 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16409 {
16410 PyThreadState* __tstate = wxPyBeginAllowThreads();
16411 wxImage::AddHandler(arg1);
16412 wxPyEndAllowThreads(__tstate);
16413 if (PyErr_Occurred()) SWIG_fail;
16414 }
16415 resultobj = SWIG_Py_Void();
16416 return resultobj;
16417 fail:
16418 return NULL;
16419 }
16420
16421
16422 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16423 PyObject *resultobj = 0;
16424 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16425 void *argp1 = 0 ;
16426 int res1 = 0 ;
16427 PyObject * obj0 = 0 ;
16428 char * kwnames[] = {
16429 (char *) "handler", NULL
16430 };
16431
16432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16434 if (!SWIG_IsOK(res1)) {
16435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16436 }
16437 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16438 {
16439 PyThreadState* __tstate = wxPyBeginAllowThreads();
16440 wxImage::InsertHandler(arg1);
16441 wxPyEndAllowThreads(__tstate);
16442 if (PyErr_Occurred()) SWIG_fail;
16443 }
16444 resultobj = SWIG_Py_Void();
16445 return resultobj;
16446 fail:
16447 return NULL;
16448 }
16449
16450
16451 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16452 PyObject *resultobj = 0;
16453 wxString *arg1 = 0 ;
16454 bool result;
16455 bool temp1 = false ;
16456 PyObject * obj0 = 0 ;
16457 char * kwnames[] = {
16458 (char *) "name", NULL
16459 };
16460
16461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16462 {
16463 arg1 = wxString_in_helper(obj0);
16464 if (arg1 == NULL) SWIG_fail;
16465 temp1 = true;
16466 }
16467 {
16468 PyThreadState* __tstate = wxPyBeginAllowThreads();
16469 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16470 wxPyEndAllowThreads(__tstate);
16471 if (PyErr_Occurred()) SWIG_fail;
16472 }
16473 {
16474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16475 }
16476 {
16477 if (temp1)
16478 delete arg1;
16479 }
16480 return resultobj;
16481 fail:
16482 {
16483 if (temp1)
16484 delete arg1;
16485 }
16486 return NULL;
16487 }
16488
16489
16490 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16491 PyObject *resultobj = 0;
16492 PyObject *result = 0 ;
16493
16494 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16495 {
16496 PyThreadState* __tstate = wxPyBeginAllowThreads();
16497 result = (PyObject *)wxImage_GetHandlers();
16498 wxPyEndAllowThreads(__tstate);
16499 if (PyErr_Occurred()) SWIG_fail;
16500 }
16501 resultobj = result;
16502 return resultobj;
16503 fail:
16504 return NULL;
16505 }
16506
16507
16508 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16509 PyObject *resultobj = 0;
16510 wxString result;
16511
16512 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16513 {
16514 PyThreadState* __tstate = wxPyBeginAllowThreads();
16515 result = wxImage::GetImageExtWildcard();
16516 wxPyEndAllowThreads(__tstate);
16517 if (PyErr_Occurred()) SWIG_fail;
16518 }
16519 {
16520 #if wxUSE_UNICODE
16521 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16522 #else
16523 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16524 #endif
16525 }
16526 return resultobj;
16527 fail:
16528 return NULL;
16529 }
16530
16531
16532 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16533 PyObject *resultobj = 0;
16534 wxImage *arg1 = (wxImage *) 0 ;
16535 int arg2 = (int) -1 ;
16536 wxBitmap result;
16537 void *argp1 = 0 ;
16538 int res1 = 0 ;
16539 int val2 ;
16540 int ecode2 = 0 ;
16541 PyObject * obj0 = 0 ;
16542 PyObject * obj1 = 0 ;
16543 char * kwnames[] = {
16544 (char *) "self",(char *) "depth", NULL
16545 };
16546
16547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16549 if (!SWIG_IsOK(res1)) {
16550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16551 }
16552 arg1 = reinterpret_cast< wxImage * >(argp1);
16553 if (obj1) {
16554 ecode2 = SWIG_AsVal_int(obj1, &val2);
16555 if (!SWIG_IsOK(ecode2)) {
16556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16557 }
16558 arg2 = static_cast< int >(val2);
16559 }
16560 {
16561 if (!wxPyCheckForApp()) SWIG_fail;
16562 PyThreadState* __tstate = wxPyBeginAllowThreads();
16563 result = wxImage_ConvertToBitmap(arg1,arg2);
16564 wxPyEndAllowThreads(__tstate);
16565 if (PyErr_Occurred()) SWIG_fail;
16566 }
16567 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16568 return resultobj;
16569 fail:
16570 return NULL;
16571 }
16572
16573
16574 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16575 PyObject *resultobj = 0;
16576 wxImage *arg1 = (wxImage *) 0 ;
16577 byte arg2 ;
16578 byte arg3 ;
16579 byte arg4 ;
16580 wxBitmap result;
16581 void *argp1 = 0 ;
16582 int res1 = 0 ;
16583 unsigned char val2 ;
16584 int ecode2 = 0 ;
16585 unsigned char val3 ;
16586 int ecode3 = 0 ;
16587 unsigned char val4 ;
16588 int ecode4 = 0 ;
16589 PyObject * obj0 = 0 ;
16590 PyObject * obj1 = 0 ;
16591 PyObject * obj2 = 0 ;
16592 PyObject * obj3 = 0 ;
16593 char * kwnames[] = {
16594 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16595 };
16596
16597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16599 if (!SWIG_IsOK(res1)) {
16600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16601 }
16602 arg1 = reinterpret_cast< wxImage * >(argp1);
16603 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16604 if (!SWIG_IsOK(ecode2)) {
16605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16606 }
16607 arg2 = static_cast< byte >(val2);
16608 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16609 if (!SWIG_IsOK(ecode3)) {
16610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16611 }
16612 arg3 = static_cast< byte >(val3);
16613 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16614 if (!SWIG_IsOK(ecode4)) {
16615 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16616 }
16617 arg4 = static_cast< byte >(val4);
16618 {
16619 if (!wxPyCheckForApp()) SWIG_fail;
16620 PyThreadState* __tstate = wxPyBeginAllowThreads();
16621 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16622 wxPyEndAllowThreads(__tstate);
16623 if (PyErr_Occurred()) SWIG_fail;
16624 }
16625 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16626 return resultobj;
16627 fail:
16628 return NULL;
16629 }
16630
16631
16632 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16633 PyObject *resultobj = 0;
16634 wxImage *arg1 = (wxImage *) 0 ;
16635 double arg2 ;
16636 void *argp1 = 0 ;
16637 int res1 = 0 ;
16638 double val2 ;
16639 int ecode2 = 0 ;
16640 PyObject * obj0 = 0 ;
16641 PyObject * obj1 = 0 ;
16642 char * kwnames[] = {
16643 (char *) "self",(char *) "angle", NULL
16644 };
16645
16646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16648 if (!SWIG_IsOK(res1)) {
16649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16650 }
16651 arg1 = reinterpret_cast< wxImage * >(argp1);
16652 ecode2 = SWIG_AsVal_double(obj1, &val2);
16653 if (!SWIG_IsOK(ecode2)) {
16654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16655 }
16656 arg2 = static_cast< double >(val2);
16657 {
16658 PyThreadState* __tstate = wxPyBeginAllowThreads();
16659 (arg1)->RotateHue(arg2);
16660 wxPyEndAllowThreads(__tstate);
16661 if (PyErr_Occurred()) SWIG_fail;
16662 }
16663 resultobj = SWIG_Py_Void();
16664 return resultobj;
16665 fail:
16666 return NULL;
16667 }
16668
16669
16670 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16671 PyObject *resultobj = 0;
16672 wxImage_RGBValue arg1 ;
16673 wxImage_HSVValue result;
16674 void *argp1 ;
16675 int res1 = 0 ;
16676 PyObject * obj0 = 0 ;
16677 char * kwnames[] = {
16678 (char *) "rgb", NULL
16679 };
16680
16681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16682 {
16683 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16684 if (!SWIG_IsOK(res1)) {
16685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16686 }
16687 if (!argp1) {
16688 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16689 } else {
16690 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16691 arg1 = *temp;
16692 if (SWIG_IsNewObj(res1)) delete temp;
16693 }
16694 }
16695 {
16696 PyThreadState* __tstate = wxPyBeginAllowThreads();
16697 result = wxImage::RGBtoHSV(arg1);
16698 wxPyEndAllowThreads(__tstate);
16699 if (PyErr_Occurred()) SWIG_fail;
16700 }
16701 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16702 return resultobj;
16703 fail:
16704 return NULL;
16705 }
16706
16707
16708 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16709 PyObject *resultobj = 0;
16710 wxImage_HSVValue arg1 ;
16711 wxImage_RGBValue result;
16712 void *argp1 ;
16713 int res1 = 0 ;
16714 PyObject * obj0 = 0 ;
16715 char * kwnames[] = {
16716 (char *) "hsv", NULL
16717 };
16718
16719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16720 {
16721 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16722 if (!SWIG_IsOK(res1)) {
16723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16724 }
16725 if (!argp1) {
16726 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16727 } else {
16728 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16729 arg1 = *temp;
16730 if (SWIG_IsNewObj(res1)) delete temp;
16731 }
16732 }
16733 {
16734 PyThreadState* __tstate = wxPyBeginAllowThreads();
16735 result = wxImage::HSVtoRGB(arg1);
16736 wxPyEndAllowThreads(__tstate);
16737 if (PyErr_Occurred()) SWIG_fail;
16738 }
16739 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16740 return resultobj;
16741 fail:
16742 return NULL;
16743 }
16744
16745
16746 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16747 PyObject *obj;
16748 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16749 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16750 return SWIG_Py_Void();
16751 }
16752
16753 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16754 return SWIG_Python_InitShadowInstance(args);
16755 }
16756
16757 SWIGINTERN int NullImage_set(PyObject *) {
16758 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16759 return 1;
16760 }
16761
16762
16763 SWIGINTERN PyObject *NullImage_get(void) {
16764 PyObject *pyobj = 0;
16765
16766 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16767 return pyobj;
16768 }
16769
16770
16771 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16772 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16773 return 1;
16774 }
16775
16776
16777 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16778 PyObject *pyobj = 0;
16779
16780 {
16781 #if wxUSE_UNICODE
16782 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16783 #else
16784 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16785 #endif
16786 }
16787 return pyobj;
16788 }
16789
16790
16791 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16792 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16793 return 1;
16794 }
16795
16796
16797 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16798 PyObject *pyobj = 0;
16799
16800 {
16801 #if wxUSE_UNICODE
16802 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16803 #else
16804 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16805 #endif
16806 }
16807 return pyobj;
16808 }
16809
16810
16811 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16812 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16813 return 1;
16814 }
16815
16816
16817 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16818 PyObject *pyobj = 0;
16819
16820 {
16821 #if wxUSE_UNICODE
16822 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16823 #else
16824 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16825 #endif
16826 }
16827 return pyobj;
16828 }
16829
16830
16831 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16832 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16833 return 1;
16834 }
16835
16836
16837 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16838 PyObject *pyobj = 0;
16839
16840 {
16841 #if wxUSE_UNICODE
16842 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16843 #else
16844 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16845 #endif
16846 }
16847 return pyobj;
16848 }
16849
16850
16851 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16852 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16853 return 1;
16854 }
16855
16856
16857 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16858 PyObject *pyobj = 0;
16859
16860 {
16861 #if wxUSE_UNICODE
16862 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16863 #else
16864 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16865 #endif
16866 }
16867 return pyobj;
16868 }
16869
16870
16871 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16872 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16873 return 1;
16874 }
16875
16876
16877 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16878 PyObject *pyobj = 0;
16879
16880 {
16881 #if wxUSE_UNICODE
16882 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16883 #else
16884 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16885 #endif
16886 }
16887 return pyobj;
16888 }
16889
16890
16891 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16892 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
16893 return 1;
16894 }
16895
16896
16897 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
16898 PyObject *pyobj = 0;
16899
16900 {
16901 #if wxUSE_UNICODE
16902 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16903 #else
16904 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16905 #endif
16906 }
16907 return pyobj;
16908 }
16909
16910
16911 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
16912 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
16913 return 1;
16914 }
16915
16916
16917 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
16918 PyObject *pyobj = 0;
16919
16920 {
16921 #if wxUSE_UNICODE
16922 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16923 #else
16924 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16925 #endif
16926 }
16927 return pyobj;
16928 }
16929
16930
16931 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
16932 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
16933 return 1;
16934 }
16935
16936
16937 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
16938 PyObject *pyobj = 0;
16939
16940 {
16941 #if wxUSE_UNICODE
16942 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16943 #else
16944 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16945 #endif
16946 }
16947 return pyobj;
16948 }
16949
16950
16951 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
16952 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
16953 return 1;
16954 }
16955
16956
16957 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
16958 PyObject *pyobj = 0;
16959
16960 {
16961 #if wxUSE_UNICODE
16962 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
16963 #else
16964 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
16965 #endif
16966 }
16967 return pyobj;
16968 }
16969
16970
16971 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
16972 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
16973 return 1;
16974 }
16975
16976
16977 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
16978 PyObject *pyobj = 0;
16979
16980 {
16981 #if wxUSE_UNICODE
16982 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
16983 #else
16984 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
16985 #endif
16986 }
16987 return pyobj;
16988 }
16989
16990
16991 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
16992 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
16993 return 1;
16994 }
16995
16996
16997 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
16998 PyObject *pyobj = 0;
16999
17000 {
17001 #if wxUSE_UNICODE
17002 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17003 #else
17004 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17005 #endif
17006 }
17007 return pyobj;
17008 }
17009
17010
17011 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17012 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17013 return 1;
17014 }
17015
17016
17017 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17018 PyObject *pyobj = 0;
17019
17020 {
17021 #if wxUSE_UNICODE
17022 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17023 #else
17024 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17025 #endif
17026 }
17027 return pyobj;
17028 }
17029
17030
17031 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17032 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17033 return 1;
17034 }
17035
17036
17037 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17038 PyObject *pyobj = 0;
17039
17040 {
17041 #if wxUSE_UNICODE
17042 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17043 #else
17044 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17045 #endif
17046 }
17047 return pyobj;
17048 }
17049
17050
17051 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17052 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17053 return 1;
17054 }
17055
17056
17057 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17058 PyObject *pyobj = 0;
17059
17060 {
17061 #if wxUSE_UNICODE
17062 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17063 #else
17064 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17065 #endif
17066 }
17067 return pyobj;
17068 }
17069
17070
17071 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17072 PyObject *resultobj = 0;
17073 wxBMPHandler *result = 0 ;
17074
17075 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17076 {
17077 PyThreadState* __tstate = wxPyBeginAllowThreads();
17078 result = (wxBMPHandler *)new wxBMPHandler();
17079 wxPyEndAllowThreads(__tstate);
17080 if (PyErr_Occurred()) SWIG_fail;
17081 }
17082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17083 return resultobj;
17084 fail:
17085 return NULL;
17086 }
17087
17088
17089 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17090 PyObject *obj;
17091 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17092 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17093 return SWIG_Py_Void();
17094 }
17095
17096 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17097 return SWIG_Python_InitShadowInstance(args);
17098 }
17099
17100 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17101 PyObject *resultobj = 0;
17102 wxICOHandler *result = 0 ;
17103
17104 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17105 {
17106 PyThreadState* __tstate = wxPyBeginAllowThreads();
17107 result = (wxICOHandler *)new wxICOHandler();
17108 wxPyEndAllowThreads(__tstate);
17109 if (PyErr_Occurred()) SWIG_fail;
17110 }
17111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17112 return resultobj;
17113 fail:
17114 return NULL;
17115 }
17116
17117
17118 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17119 PyObject *obj;
17120 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17121 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17122 return SWIG_Py_Void();
17123 }
17124
17125 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17126 return SWIG_Python_InitShadowInstance(args);
17127 }
17128
17129 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17130 PyObject *resultobj = 0;
17131 wxCURHandler *result = 0 ;
17132
17133 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17134 {
17135 PyThreadState* __tstate = wxPyBeginAllowThreads();
17136 result = (wxCURHandler *)new wxCURHandler();
17137 wxPyEndAllowThreads(__tstate);
17138 if (PyErr_Occurred()) SWIG_fail;
17139 }
17140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17141 return resultobj;
17142 fail:
17143 return NULL;
17144 }
17145
17146
17147 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17148 PyObject *obj;
17149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17150 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17151 return SWIG_Py_Void();
17152 }
17153
17154 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17155 return SWIG_Python_InitShadowInstance(args);
17156 }
17157
17158 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17159 PyObject *resultobj = 0;
17160 wxANIHandler *result = 0 ;
17161
17162 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17163 {
17164 PyThreadState* __tstate = wxPyBeginAllowThreads();
17165 result = (wxANIHandler *)new wxANIHandler();
17166 wxPyEndAllowThreads(__tstate);
17167 if (PyErr_Occurred()) SWIG_fail;
17168 }
17169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17170 return resultobj;
17171 fail:
17172 return NULL;
17173 }
17174
17175
17176 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17177 PyObject *obj;
17178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17179 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17180 return SWIG_Py_Void();
17181 }
17182
17183 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17184 return SWIG_Python_InitShadowInstance(args);
17185 }
17186
17187 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17188 PyObject *resultobj = 0;
17189 wxPNGHandler *result = 0 ;
17190
17191 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17192 {
17193 PyThreadState* __tstate = wxPyBeginAllowThreads();
17194 result = (wxPNGHandler *)new wxPNGHandler();
17195 wxPyEndAllowThreads(__tstate);
17196 if (PyErr_Occurred()) SWIG_fail;
17197 }
17198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17199 return resultobj;
17200 fail:
17201 return NULL;
17202 }
17203
17204
17205 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17206 PyObject *obj;
17207 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17208 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17209 return SWIG_Py_Void();
17210 }
17211
17212 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17213 return SWIG_Python_InitShadowInstance(args);
17214 }
17215
17216 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17217 PyObject *resultobj = 0;
17218 wxGIFHandler *result = 0 ;
17219
17220 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17221 {
17222 PyThreadState* __tstate = wxPyBeginAllowThreads();
17223 result = (wxGIFHandler *)new wxGIFHandler();
17224 wxPyEndAllowThreads(__tstate);
17225 if (PyErr_Occurred()) SWIG_fail;
17226 }
17227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17228 return resultobj;
17229 fail:
17230 return NULL;
17231 }
17232
17233
17234 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17235 PyObject *obj;
17236 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17237 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17238 return SWIG_Py_Void();
17239 }
17240
17241 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17242 return SWIG_Python_InitShadowInstance(args);
17243 }
17244
17245 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17246 PyObject *resultobj = 0;
17247 wxPCXHandler *result = 0 ;
17248
17249 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17250 {
17251 PyThreadState* __tstate = wxPyBeginAllowThreads();
17252 result = (wxPCXHandler *)new wxPCXHandler();
17253 wxPyEndAllowThreads(__tstate);
17254 if (PyErr_Occurred()) SWIG_fail;
17255 }
17256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17257 return resultobj;
17258 fail:
17259 return NULL;
17260 }
17261
17262
17263 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17264 PyObject *obj;
17265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17266 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17267 return SWIG_Py_Void();
17268 }
17269
17270 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17271 return SWIG_Python_InitShadowInstance(args);
17272 }
17273
17274 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17275 PyObject *resultobj = 0;
17276 wxJPEGHandler *result = 0 ;
17277
17278 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17279 {
17280 PyThreadState* __tstate = wxPyBeginAllowThreads();
17281 result = (wxJPEGHandler *)new wxJPEGHandler();
17282 wxPyEndAllowThreads(__tstate);
17283 if (PyErr_Occurred()) SWIG_fail;
17284 }
17285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17286 return resultobj;
17287 fail:
17288 return NULL;
17289 }
17290
17291
17292 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17293 PyObject *obj;
17294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17295 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17296 return SWIG_Py_Void();
17297 }
17298
17299 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17300 return SWIG_Python_InitShadowInstance(args);
17301 }
17302
17303 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17304 PyObject *resultobj = 0;
17305 wxPNMHandler *result = 0 ;
17306
17307 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17308 {
17309 PyThreadState* __tstate = wxPyBeginAllowThreads();
17310 result = (wxPNMHandler *)new wxPNMHandler();
17311 wxPyEndAllowThreads(__tstate);
17312 if (PyErr_Occurred()) SWIG_fail;
17313 }
17314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17315 return resultobj;
17316 fail:
17317 return NULL;
17318 }
17319
17320
17321 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17322 PyObject *obj;
17323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17324 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17325 return SWIG_Py_Void();
17326 }
17327
17328 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17329 return SWIG_Python_InitShadowInstance(args);
17330 }
17331
17332 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17333 PyObject *resultobj = 0;
17334 wxXPMHandler *result = 0 ;
17335
17336 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17337 {
17338 PyThreadState* __tstate = wxPyBeginAllowThreads();
17339 result = (wxXPMHandler *)new wxXPMHandler();
17340 wxPyEndAllowThreads(__tstate);
17341 if (PyErr_Occurred()) SWIG_fail;
17342 }
17343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17344 return resultobj;
17345 fail:
17346 return NULL;
17347 }
17348
17349
17350 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17351 PyObject *obj;
17352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17353 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17354 return SWIG_Py_Void();
17355 }
17356
17357 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17358 return SWIG_Python_InitShadowInstance(args);
17359 }
17360
17361 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17362 PyObject *resultobj = 0;
17363 wxTIFFHandler *result = 0 ;
17364
17365 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17366 {
17367 PyThreadState* __tstate = wxPyBeginAllowThreads();
17368 result = (wxTIFFHandler *)new wxTIFFHandler();
17369 wxPyEndAllowThreads(__tstate);
17370 if (PyErr_Occurred()) SWIG_fail;
17371 }
17372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17373 return resultobj;
17374 fail:
17375 return NULL;
17376 }
17377
17378
17379 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17380 PyObject *obj;
17381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17382 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17383 return SWIG_Py_Void();
17384 }
17385
17386 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17387 return SWIG_Python_InitShadowInstance(args);
17388 }
17389
17390 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17391 PyObject *resultobj = 0;
17392 wxImage *arg1 = 0 ;
17393 wxImage *arg2 = 0 ;
17394 int arg3 = (int) 236 ;
17395 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17396 bool result;
17397 void *argp1 = 0 ;
17398 int res1 = 0 ;
17399 void *argp2 = 0 ;
17400 int res2 = 0 ;
17401 int val3 ;
17402 int ecode3 = 0 ;
17403 int val4 ;
17404 int ecode4 = 0 ;
17405 PyObject * obj0 = 0 ;
17406 PyObject * obj1 = 0 ;
17407 PyObject * obj2 = 0 ;
17408 PyObject * obj3 = 0 ;
17409 char * kwnames[] = {
17410 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17411 };
17412
17413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17414 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17415 if (!SWIG_IsOK(res1)) {
17416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17417 }
17418 if (!argp1) {
17419 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17420 }
17421 arg1 = reinterpret_cast< wxImage * >(argp1);
17422 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17423 if (!SWIG_IsOK(res2)) {
17424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17425 }
17426 if (!argp2) {
17427 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17428 }
17429 arg2 = reinterpret_cast< wxImage * >(argp2);
17430 if (obj2) {
17431 ecode3 = SWIG_AsVal_int(obj2, &val3);
17432 if (!SWIG_IsOK(ecode3)) {
17433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17434 }
17435 arg3 = static_cast< int >(val3);
17436 }
17437 if (obj3) {
17438 ecode4 = SWIG_AsVal_int(obj3, &val4);
17439 if (!SWIG_IsOK(ecode4)) {
17440 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17441 }
17442 arg4 = static_cast< int >(val4);
17443 }
17444 {
17445 PyThreadState* __tstate = wxPyBeginAllowThreads();
17446 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17447 wxPyEndAllowThreads(__tstate);
17448 if (PyErr_Occurred()) SWIG_fail;
17449 }
17450 {
17451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17452 }
17453 return resultobj;
17454 fail:
17455 return NULL;
17456 }
17457
17458
17459 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17460 PyObject *obj;
17461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17462 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17463 return SWIG_Py_Void();
17464 }
17465
17466 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17467 PyObject *resultobj = 0;
17468 wxEvtHandler *result = 0 ;
17469
17470 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17471 {
17472 PyThreadState* __tstate = wxPyBeginAllowThreads();
17473 result = (wxEvtHandler *)new wxEvtHandler();
17474 wxPyEndAllowThreads(__tstate);
17475 if (PyErr_Occurred()) SWIG_fail;
17476 }
17477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17478 return resultobj;
17479 fail:
17480 return NULL;
17481 }
17482
17483
17484 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17485 PyObject *resultobj = 0;
17486 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17487 wxEvtHandler *result = 0 ;
17488 void *argp1 = 0 ;
17489 int res1 = 0 ;
17490 PyObject *swig_obj[1] ;
17491
17492 if (!args) SWIG_fail;
17493 swig_obj[0] = args;
17494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17495 if (!SWIG_IsOK(res1)) {
17496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17497 }
17498 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17499 {
17500 PyThreadState* __tstate = wxPyBeginAllowThreads();
17501 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17502 wxPyEndAllowThreads(__tstate);
17503 if (PyErr_Occurred()) SWIG_fail;
17504 }
17505 {
17506 resultobj = wxPyMake_wxObject(result, 0);
17507 }
17508 return resultobj;
17509 fail:
17510 return NULL;
17511 }
17512
17513
17514 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17515 PyObject *resultobj = 0;
17516 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17517 wxEvtHandler *result = 0 ;
17518 void *argp1 = 0 ;
17519 int res1 = 0 ;
17520 PyObject *swig_obj[1] ;
17521
17522 if (!args) SWIG_fail;
17523 swig_obj[0] = args;
17524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17525 if (!SWIG_IsOK(res1)) {
17526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17527 }
17528 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17529 {
17530 PyThreadState* __tstate = wxPyBeginAllowThreads();
17531 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17532 wxPyEndAllowThreads(__tstate);
17533 if (PyErr_Occurred()) SWIG_fail;
17534 }
17535 {
17536 resultobj = wxPyMake_wxObject(result, 0);
17537 }
17538 return resultobj;
17539 fail:
17540 return NULL;
17541 }
17542
17543
17544 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17545 PyObject *resultobj = 0;
17546 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17547 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17548 void *argp1 = 0 ;
17549 int res1 = 0 ;
17550 void *argp2 = 0 ;
17551 int res2 = 0 ;
17552 PyObject * obj0 = 0 ;
17553 PyObject * obj1 = 0 ;
17554 char * kwnames[] = {
17555 (char *) "self",(char *) "handler", NULL
17556 };
17557
17558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17560 if (!SWIG_IsOK(res1)) {
17561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17562 }
17563 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17564 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17565 if (!SWIG_IsOK(res2)) {
17566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17567 }
17568 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17569 {
17570 PyThreadState* __tstate = wxPyBeginAllowThreads();
17571 (arg1)->SetNextHandler(arg2);
17572 wxPyEndAllowThreads(__tstate);
17573 if (PyErr_Occurred()) SWIG_fail;
17574 }
17575 resultobj = SWIG_Py_Void();
17576 return resultobj;
17577 fail:
17578 return NULL;
17579 }
17580
17581
17582 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17583 PyObject *resultobj = 0;
17584 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17585 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17586 void *argp1 = 0 ;
17587 int res1 = 0 ;
17588 void *argp2 = 0 ;
17589 int res2 = 0 ;
17590 PyObject * obj0 = 0 ;
17591 PyObject * obj1 = 0 ;
17592 char * kwnames[] = {
17593 (char *) "self",(char *) "handler", NULL
17594 };
17595
17596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17598 if (!SWIG_IsOK(res1)) {
17599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17600 }
17601 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17602 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17603 if (!SWIG_IsOK(res2)) {
17604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17605 }
17606 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17607 {
17608 PyThreadState* __tstate = wxPyBeginAllowThreads();
17609 (arg1)->SetPreviousHandler(arg2);
17610 wxPyEndAllowThreads(__tstate);
17611 if (PyErr_Occurred()) SWIG_fail;
17612 }
17613 resultobj = SWIG_Py_Void();
17614 return resultobj;
17615 fail:
17616 return NULL;
17617 }
17618
17619
17620 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17621 PyObject *resultobj = 0;
17622 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17623 bool result;
17624 void *argp1 = 0 ;
17625 int res1 = 0 ;
17626 PyObject *swig_obj[1] ;
17627
17628 if (!args) SWIG_fail;
17629 swig_obj[0] = args;
17630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17631 if (!SWIG_IsOK(res1)) {
17632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17633 }
17634 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17635 {
17636 PyThreadState* __tstate = wxPyBeginAllowThreads();
17637 result = (bool)(arg1)->GetEvtHandlerEnabled();
17638 wxPyEndAllowThreads(__tstate);
17639 if (PyErr_Occurred()) SWIG_fail;
17640 }
17641 {
17642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17643 }
17644 return resultobj;
17645 fail:
17646 return NULL;
17647 }
17648
17649
17650 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17651 PyObject *resultobj = 0;
17652 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17653 bool arg2 ;
17654 void *argp1 = 0 ;
17655 int res1 = 0 ;
17656 bool val2 ;
17657 int ecode2 = 0 ;
17658 PyObject * obj0 = 0 ;
17659 PyObject * obj1 = 0 ;
17660 char * kwnames[] = {
17661 (char *) "self",(char *) "enabled", NULL
17662 };
17663
17664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17666 if (!SWIG_IsOK(res1)) {
17667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17668 }
17669 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17670 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17671 if (!SWIG_IsOK(ecode2)) {
17672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17673 }
17674 arg2 = static_cast< bool >(val2);
17675 {
17676 PyThreadState* __tstate = wxPyBeginAllowThreads();
17677 (arg1)->SetEvtHandlerEnabled(arg2);
17678 wxPyEndAllowThreads(__tstate);
17679 if (PyErr_Occurred()) SWIG_fail;
17680 }
17681 resultobj = SWIG_Py_Void();
17682 return resultobj;
17683 fail:
17684 return NULL;
17685 }
17686
17687
17688 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17689 PyObject *resultobj = 0;
17690 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17691 wxEvent *arg2 = 0 ;
17692 bool result;
17693 void *argp1 = 0 ;
17694 int res1 = 0 ;
17695 void *argp2 = 0 ;
17696 int res2 = 0 ;
17697 PyObject * obj0 = 0 ;
17698 PyObject * obj1 = 0 ;
17699 char * kwnames[] = {
17700 (char *) "self",(char *) "event", NULL
17701 };
17702
17703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17705 if (!SWIG_IsOK(res1)) {
17706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17707 }
17708 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17709 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17710 if (!SWIG_IsOK(res2)) {
17711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17712 }
17713 if (!argp2) {
17714 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17715 }
17716 arg2 = reinterpret_cast< wxEvent * >(argp2);
17717 {
17718 PyThreadState* __tstate = wxPyBeginAllowThreads();
17719 result = (bool)(arg1)->ProcessEvent(*arg2);
17720 wxPyEndAllowThreads(__tstate);
17721 if (PyErr_Occurred()) SWIG_fail;
17722 }
17723 {
17724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17725 }
17726 return resultobj;
17727 fail:
17728 return NULL;
17729 }
17730
17731
17732 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17733 PyObject *resultobj = 0;
17734 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17735 wxEvent *arg2 = 0 ;
17736 void *argp1 = 0 ;
17737 int res1 = 0 ;
17738 void *argp2 = 0 ;
17739 int res2 = 0 ;
17740 PyObject * obj0 = 0 ;
17741 PyObject * obj1 = 0 ;
17742 char * kwnames[] = {
17743 (char *) "self",(char *) "event", NULL
17744 };
17745
17746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17748 if (!SWIG_IsOK(res1)) {
17749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17750 }
17751 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17752 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17753 if (!SWIG_IsOK(res2)) {
17754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17755 }
17756 if (!argp2) {
17757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17758 }
17759 arg2 = reinterpret_cast< wxEvent * >(argp2);
17760 {
17761 PyThreadState* __tstate = wxPyBeginAllowThreads();
17762 (arg1)->AddPendingEvent(*arg2);
17763 wxPyEndAllowThreads(__tstate);
17764 if (PyErr_Occurred()) SWIG_fail;
17765 }
17766 resultobj = SWIG_Py_Void();
17767 return resultobj;
17768 fail:
17769 return NULL;
17770 }
17771
17772
17773 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17774 PyObject *resultobj = 0;
17775 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17776 void *argp1 = 0 ;
17777 int res1 = 0 ;
17778 PyObject *swig_obj[1] ;
17779
17780 if (!args) SWIG_fail;
17781 swig_obj[0] = args;
17782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17783 if (!SWIG_IsOK(res1)) {
17784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17785 }
17786 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17787 {
17788 PyThreadState* __tstate = wxPyBeginAllowThreads();
17789 (arg1)->ProcessPendingEvents();
17790 wxPyEndAllowThreads(__tstate);
17791 if (PyErr_Occurred()) SWIG_fail;
17792 }
17793 resultobj = SWIG_Py_Void();
17794 return resultobj;
17795 fail:
17796 return NULL;
17797 }
17798
17799
17800 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17801 PyObject *resultobj = 0;
17802 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17803 int arg2 ;
17804 int arg3 ;
17805 int arg4 ;
17806 PyObject *arg5 = (PyObject *) 0 ;
17807 void *argp1 = 0 ;
17808 int res1 = 0 ;
17809 int val2 ;
17810 int ecode2 = 0 ;
17811 int val3 ;
17812 int ecode3 = 0 ;
17813 int val4 ;
17814 int ecode4 = 0 ;
17815 PyObject * obj0 = 0 ;
17816 PyObject * obj1 = 0 ;
17817 PyObject * obj2 = 0 ;
17818 PyObject * obj3 = 0 ;
17819 PyObject * obj4 = 0 ;
17820 char * kwnames[] = {
17821 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17822 };
17823
17824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17826 if (!SWIG_IsOK(res1)) {
17827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17828 }
17829 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17830 ecode2 = SWIG_AsVal_int(obj1, &val2);
17831 if (!SWIG_IsOK(ecode2)) {
17832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17833 }
17834 arg2 = static_cast< int >(val2);
17835 ecode3 = SWIG_AsVal_int(obj2, &val3);
17836 if (!SWIG_IsOK(ecode3)) {
17837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17838 }
17839 arg3 = static_cast< int >(val3);
17840 ecode4 = SWIG_AsVal_int(obj3, &val4);
17841 if (!SWIG_IsOK(ecode4)) {
17842 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17843 }
17844 arg4 = static_cast< int >(val4);
17845 arg5 = obj4;
17846 {
17847 PyThreadState* __tstate = wxPyBeginAllowThreads();
17848 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17849 wxPyEndAllowThreads(__tstate);
17850 if (PyErr_Occurred()) SWIG_fail;
17851 }
17852 resultobj = SWIG_Py_Void();
17853 return resultobj;
17854 fail:
17855 return NULL;
17856 }
17857
17858
17859 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17860 PyObject *resultobj = 0;
17861 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17862 int arg2 ;
17863 int arg3 = (int) -1 ;
17864 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17865 bool result;
17866 void *argp1 = 0 ;
17867 int res1 = 0 ;
17868 int val2 ;
17869 int ecode2 = 0 ;
17870 int val3 ;
17871 int ecode3 = 0 ;
17872 int val4 ;
17873 int ecode4 = 0 ;
17874 PyObject * obj0 = 0 ;
17875 PyObject * obj1 = 0 ;
17876 PyObject * obj2 = 0 ;
17877 PyObject * obj3 = 0 ;
17878 char * kwnames[] = {
17879 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17880 };
17881
17882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17884 if (!SWIG_IsOK(res1)) {
17885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17886 }
17887 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17888 ecode2 = SWIG_AsVal_int(obj1, &val2);
17889 if (!SWIG_IsOK(ecode2)) {
17890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17891 }
17892 arg2 = static_cast< int >(val2);
17893 if (obj2) {
17894 ecode3 = SWIG_AsVal_int(obj2, &val3);
17895 if (!SWIG_IsOK(ecode3)) {
17896 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
17897 }
17898 arg3 = static_cast< int >(val3);
17899 }
17900 if (obj3) {
17901 ecode4 = SWIG_AsVal_int(obj3, &val4);
17902 if (!SWIG_IsOK(ecode4)) {
17903 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
17904 }
17905 arg4 = static_cast< wxEventType >(val4);
17906 }
17907 {
17908 PyThreadState* __tstate = wxPyBeginAllowThreads();
17909 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
17910 wxPyEndAllowThreads(__tstate);
17911 if (PyErr_Occurred()) SWIG_fail;
17912 }
17913 {
17914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17915 }
17916 return resultobj;
17917 fail:
17918 return NULL;
17919 }
17920
17921
17922 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17923 PyObject *resultobj = 0;
17924 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17925 PyObject *arg2 = (PyObject *) 0 ;
17926 bool arg3 = (bool) true ;
17927 void *argp1 = 0 ;
17928 int res1 = 0 ;
17929 bool val3 ;
17930 int ecode3 = 0 ;
17931 PyObject * obj0 = 0 ;
17932 PyObject * obj1 = 0 ;
17933 PyObject * obj2 = 0 ;
17934 char * kwnames[] = {
17935 (char *) "self",(char *) "_self",(char *) "incref", NULL
17936 };
17937
17938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17940 if (!SWIG_IsOK(res1)) {
17941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17942 }
17943 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17944 arg2 = obj1;
17945 if (obj2) {
17946 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17947 if (!SWIG_IsOK(ecode3)) {
17948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
17949 }
17950 arg3 = static_cast< bool >(val3);
17951 }
17952 {
17953 PyThreadState* __tstate = wxPyBeginAllowThreads();
17954 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
17955 wxPyEndAllowThreads(__tstate);
17956 if (PyErr_Occurred()) SWIG_fail;
17957 }
17958 resultobj = SWIG_Py_Void();
17959 return resultobj;
17960 fail:
17961 return NULL;
17962 }
17963
17964
17965 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17966 PyObject *obj;
17967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17968 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
17969 return SWIG_Py_Void();
17970 }
17971
17972 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17973 return SWIG_Python_InitShadowInstance(args);
17974 }
17975
17976 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17977 PyObject *resultobj = 0;
17978 wxEventType result;
17979
17980 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
17981 {
17982 PyThreadState* __tstate = wxPyBeginAllowThreads();
17983 result = (wxEventType)wxNewEventType();
17984 wxPyEndAllowThreads(__tstate);
17985 if (PyErr_Occurred()) SWIG_fail;
17986 }
17987 resultobj = SWIG_From_int(static_cast< int >(result));
17988 return resultobj;
17989 fail:
17990 return NULL;
17991 }
17992
17993
17994 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17995 PyObject *resultobj = 0;
17996 wxEvent *arg1 = (wxEvent *) 0 ;
17997 void *argp1 = 0 ;
17998 int res1 = 0 ;
17999 PyObject *swig_obj[1] ;
18000
18001 if (!args) SWIG_fail;
18002 swig_obj[0] = args;
18003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18004 if (!SWIG_IsOK(res1)) {
18005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18006 }
18007 arg1 = reinterpret_cast< wxEvent * >(argp1);
18008 {
18009 PyThreadState* __tstate = wxPyBeginAllowThreads();
18010 delete arg1;
18011
18012 wxPyEndAllowThreads(__tstate);
18013 if (PyErr_Occurred()) SWIG_fail;
18014 }
18015 resultobj = SWIG_Py_Void();
18016 return resultobj;
18017 fail:
18018 return NULL;
18019 }
18020
18021
18022 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18023 PyObject *resultobj = 0;
18024 wxEvent *arg1 = (wxEvent *) 0 ;
18025 wxEventType arg2 ;
18026 void *argp1 = 0 ;
18027 int res1 = 0 ;
18028 int val2 ;
18029 int ecode2 = 0 ;
18030 PyObject * obj0 = 0 ;
18031 PyObject * obj1 = 0 ;
18032 char * kwnames[] = {
18033 (char *) "self",(char *) "typ", NULL
18034 };
18035
18036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18038 if (!SWIG_IsOK(res1)) {
18039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18040 }
18041 arg1 = reinterpret_cast< wxEvent * >(argp1);
18042 ecode2 = SWIG_AsVal_int(obj1, &val2);
18043 if (!SWIG_IsOK(ecode2)) {
18044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18045 }
18046 arg2 = static_cast< wxEventType >(val2);
18047 {
18048 PyThreadState* __tstate = wxPyBeginAllowThreads();
18049 (arg1)->SetEventType(arg2);
18050 wxPyEndAllowThreads(__tstate);
18051 if (PyErr_Occurred()) SWIG_fail;
18052 }
18053 resultobj = SWIG_Py_Void();
18054 return resultobj;
18055 fail:
18056 return NULL;
18057 }
18058
18059
18060 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18061 PyObject *resultobj = 0;
18062 wxEvent *arg1 = (wxEvent *) 0 ;
18063 wxEventType result;
18064 void *argp1 = 0 ;
18065 int res1 = 0 ;
18066 PyObject *swig_obj[1] ;
18067
18068 if (!args) SWIG_fail;
18069 swig_obj[0] = args;
18070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18071 if (!SWIG_IsOK(res1)) {
18072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18073 }
18074 arg1 = reinterpret_cast< wxEvent * >(argp1);
18075 {
18076 PyThreadState* __tstate = wxPyBeginAllowThreads();
18077 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18078 wxPyEndAllowThreads(__tstate);
18079 if (PyErr_Occurred()) SWIG_fail;
18080 }
18081 resultobj = SWIG_From_int(static_cast< int >(result));
18082 return resultobj;
18083 fail:
18084 return NULL;
18085 }
18086
18087
18088 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18089 PyObject *resultobj = 0;
18090 wxEvent *arg1 = (wxEvent *) 0 ;
18091 wxObject *result = 0 ;
18092 void *argp1 = 0 ;
18093 int res1 = 0 ;
18094 PyObject *swig_obj[1] ;
18095
18096 if (!args) SWIG_fail;
18097 swig_obj[0] = args;
18098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18099 if (!SWIG_IsOK(res1)) {
18100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18101 }
18102 arg1 = reinterpret_cast< wxEvent * >(argp1);
18103 {
18104 PyThreadState* __tstate = wxPyBeginAllowThreads();
18105 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18106 wxPyEndAllowThreads(__tstate);
18107 if (PyErr_Occurred()) SWIG_fail;
18108 }
18109 {
18110 resultobj = wxPyMake_wxObject(result, (bool)0);
18111 }
18112 return resultobj;
18113 fail:
18114 return NULL;
18115 }
18116
18117
18118 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18119 PyObject *resultobj = 0;
18120 wxEvent *arg1 = (wxEvent *) 0 ;
18121 wxObject *arg2 = (wxObject *) 0 ;
18122 void *argp1 = 0 ;
18123 int res1 = 0 ;
18124 void *argp2 = 0 ;
18125 int res2 = 0 ;
18126 PyObject * obj0 = 0 ;
18127 PyObject * obj1 = 0 ;
18128 char * kwnames[] = {
18129 (char *) "self",(char *) "obj", NULL
18130 };
18131
18132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18134 if (!SWIG_IsOK(res1)) {
18135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18136 }
18137 arg1 = reinterpret_cast< wxEvent * >(argp1);
18138 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18139 if (!SWIG_IsOK(res2)) {
18140 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18141 }
18142 arg2 = reinterpret_cast< wxObject * >(argp2);
18143 {
18144 PyThreadState* __tstate = wxPyBeginAllowThreads();
18145 (arg1)->SetEventObject(arg2);
18146 wxPyEndAllowThreads(__tstate);
18147 if (PyErr_Occurred()) SWIG_fail;
18148 }
18149 resultobj = SWIG_Py_Void();
18150 return resultobj;
18151 fail:
18152 return NULL;
18153 }
18154
18155
18156 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18157 PyObject *resultobj = 0;
18158 wxEvent *arg1 = (wxEvent *) 0 ;
18159 long result;
18160 void *argp1 = 0 ;
18161 int res1 = 0 ;
18162 PyObject *swig_obj[1] ;
18163
18164 if (!args) SWIG_fail;
18165 swig_obj[0] = args;
18166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18167 if (!SWIG_IsOK(res1)) {
18168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18169 }
18170 arg1 = reinterpret_cast< wxEvent * >(argp1);
18171 {
18172 PyThreadState* __tstate = wxPyBeginAllowThreads();
18173 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18174 wxPyEndAllowThreads(__tstate);
18175 if (PyErr_Occurred()) SWIG_fail;
18176 }
18177 resultobj = SWIG_From_long(static_cast< long >(result));
18178 return resultobj;
18179 fail:
18180 return NULL;
18181 }
18182
18183
18184 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18185 PyObject *resultobj = 0;
18186 wxEvent *arg1 = (wxEvent *) 0 ;
18187 long arg2 = (long) 0 ;
18188 void *argp1 = 0 ;
18189 int res1 = 0 ;
18190 long val2 ;
18191 int ecode2 = 0 ;
18192 PyObject * obj0 = 0 ;
18193 PyObject * obj1 = 0 ;
18194 char * kwnames[] = {
18195 (char *) "self",(char *) "ts", NULL
18196 };
18197
18198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18200 if (!SWIG_IsOK(res1)) {
18201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18202 }
18203 arg1 = reinterpret_cast< wxEvent * >(argp1);
18204 if (obj1) {
18205 ecode2 = SWIG_AsVal_long(obj1, &val2);
18206 if (!SWIG_IsOK(ecode2)) {
18207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18208 }
18209 arg2 = static_cast< long >(val2);
18210 }
18211 {
18212 PyThreadState* __tstate = wxPyBeginAllowThreads();
18213 (arg1)->SetTimestamp(arg2);
18214 wxPyEndAllowThreads(__tstate);
18215 if (PyErr_Occurred()) SWIG_fail;
18216 }
18217 resultobj = SWIG_Py_Void();
18218 return resultobj;
18219 fail:
18220 return NULL;
18221 }
18222
18223
18224 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18225 PyObject *resultobj = 0;
18226 wxEvent *arg1 = (wxEvent *) 0 ;
18227 int result;
18228 void *argp1 = 0 ;
18229 int res1 = 0 ;
18230 PyObject *swig_obj[1] ;
18231
18232 if (!args) SWIG_fail;
18233 swig_obj[0] = args;
18234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18235 if (!SWIG_IsOK(res1)) {
18236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18237 }
18238 arg1 = reinterpret_cast< wxEvent * >(argp1);
18239 {
18240 PyThreadState* __tstate = wxPyBeginAllowThreads();
18241 result = (int)((wxEvent const *)arg1)->GetId();
18242 wxPyEndAllowThreads(__tstate);
18243 if (PyErr_Occurred()) SWIG_fail;
18244 }
18245 resultobj = SWIG_From_int(static_cast< int >(result));
18246 return resultobj;
18247 fail:
18248 return NULL;
18249 }
18250
18251
18252 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18253 PyObject *resultobj = 0;
18254 wxEvent *arg1 = (wxEvent *) 0 ;
18255 int arg2 ;
18256 void *argp1 = 0 ;
18257 int res1 = 0 ;
18258 int val2 ;
18259 int ecode2 = 0 ;
18260 PyObject * obj0 = 0 ;
18261 PyObject * obj1 = 0 ;
18262 char * kwnames[] = {
18263 (char *) "self",(char *) "Id", NULL
18264 };
18265
18266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18268 if (!SWIG_IsOK(res1)) {
18269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18270 }
18271 arg1 = reinterpret_cast< wxEvent * >(argp1);
18272 ecode2 = SWIG_AsVal_int(obj1, &val2);
18273 if (!SWIG_IsOK(ecode2)) {
18274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18275 }
18276 arg2 = static_cast< int >(val2);
18277 {
18278 PyThreadState* __tstate = wxPyBeginAllowThreads();
18279 (arg1)->SetId(arg2);
18280 wxPyEndAllowThreads(__tstate);
18281 if (PyErr_Occurred()) SWIG_fail;
18282 }
18283 resultobj = SWIG_Py_Void();
18284 return resultobj;
18285 fail:
18286 return NULL;
18287 }
18288
18289
18290 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18291 PyObject *resultobj = 0;
18292 wxEvent *arg1 = (wxEvent *) 0 ;
18293 bool result;
18294 void *argp1 = 0 ;
18295 int res1 = 0 ;
18296 PyObject *swig_obj[1] ;
18297
18298 if (!args) SWIG_fail;
18299 swig_obj[0] = args;
18300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18301 if (!SWIG_IsOK(res1)) {
18302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18303 }
18304 arg1 = reinterpret_cast< wxEvent * >(argp1);
18305 {
18306 PyThreadState* __tstate = wxPyBeginAllowThreads();
18307 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18308 wxPyEndAllowThreads(__tstate);
18309 if (PyErr_Occurred()) SWIG_fail;
18310 }
18311 {
18312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18313 }
18314 return resultobj;
18315 fail:
18316 return NULL;
18317 }
18318
18319
18320 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18321 PyObject *resultobj = 0;
18322 wxEvent *arg1 = (wxEvent *) 0 ;
18323 bool arg2 = (bool) true ;
18324 void *argp1 = 0 ;
18325 int res1 = 0 ;
18326 bool val2 ;
18327 int ecode2 = 0 ;
18328 PyObject * obj0 = 0 ;
18329 PyObject * obj1 = 0 ;
18330 char * kwnames[] = {
18331 (char *) "self",(char *) "skip", NULL
18332 };
18333
18334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18336 if (!SWIG_IsOK(res1)) {
18337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18338 }
18339 arg1 = reinterpret_cast< wxEvent * >(argp1);
18340 if (obj1) {
18341 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18342 if (!SWIG_IsOK(ecode2)) {
18343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18344 }
18345 arg2 = static_cast< bool >(val2);
18346 }
18347 {
18348 PyThreadState* __tstate = wxPyBeginAllowThreads();
18349 (arg1)->Skip(arg2);
18350 wxPyEndAllowThreads(__tstate);
18351 if (PyErr_Occurred()) SWIG_fail;
18352 }
18353 resultobj = SWIG_Py_Void();
18354 return resultobj;
18355 fail:
18356 return NULL;
18357 }
18358
18359
18360 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18361 PyObject *resultobj = 0;
18362 wxEvent *arg1 = (wxEvent *) 0 ;
18363 bool result;
18364 void *argp1 = 0 ;
18365 int res1 = 0 ;
18366 PyObject *swig_obj[1] ;
18367
18368 if (!args) SWIG_fail;
18369 swig_obj[0] = args;
18370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18371 if (!SWIG_IsOK(res1)) {
18372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18373 }
18374 arg1 = reinterpret_cast< wxEvent * >(argp1);
18375 {
18376 PyThreadState* __tstate = wxPyBeginAllowThreads();
18377 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18378 wxPyEndAllowThreads(__tstate);
18379 if (PyErr_Occurred()) SWIG_fail;
18380 }
18381 {
18382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18383 }
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18391 PyObject *resultobj = 0;
18392 wxEvent *arg1 = (wxEvent *) 0 ;
18393 bool result;
18394 void *argp1 = 0 ;
18395 int res1 = 0 ;
18396 PyObject *swig_obj[1] ;
18397
18398 if (!args) SWIG_fail;
18399 swig_obj[0] = args;
18400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18401 if (!SWIG_IsOK(res1)) {
18402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18403 }
18404 arg1 = reinterpret_cast< wxEvent * >(argp1);
18405 {
18406 PyThreadState* __tstate = wxPyBeginAllowThreads();
18407 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18408 wxPyEndAllowThreads(__tstate);
18409 if (PyErr_Occurred()) SWIG_fail;
18410 }
18411 {
18412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18413 }
18414 return resultobj;
18415 fail:
18416 return NULL;
18417 }
18418
18419
18420 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18421 PyObject *resultobj = 0;
18422 wxEvent *arg1 = (wxEvent *) 0 ;
18423 int result;
18424 void *argp1 = 0 ;
18425 int res1 = 0 ;
18426 PyObject *swig_obj[1] ;
18427
18428 if (!args) SWIG_fail;
18429 swig_obj[0] = args;
18430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18431 if (!SWIG_IsOK(res1)) {
18432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18433 }
18434 arg1 = reinterpret_cast< wxEvent * >(argp1);
18435 {
18436 PyThreadState* __tstate = wxPyBeginAllowThreads();
18437 result = (int)(arg1)->StopPropagation();
18438 wxPyEndAllowThreads(__tstate);
18439 if (PyErr_Occurred()) SWIG_fail;
18440 }
18441 resultobj = SWIG_From_int(static_cast< int >(result));
18442 return resultobj;
18443 fail:
18444 return NULL;
18445 }
18446
18447
18448 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18449 PyObject *resultobj = 0;
18450 wxEvent *arg1 = (wxEvent *) 0 ;
18451 int arg2 ;
18452 void *argp1 = 0 ;
18453 int res1 = 0 ;
18454 int val2 ;
18455 int ecode2 = 0 ;
18456 PyObject * obj0 = 0 ;
18457 PyObject * obj1 = 0 ;
18458 char * kwnames[] = {
18459 (char *) "self",(char *) "propagationLevel", NULL
18460 };
18461
18462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18464 if (!SWIG_IsOK(res1)) {
18465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18466 }
18467 arg1 = reinterpret_cast< wxEvent * >(argp1);
18468 ecode2 = SWIG_AsVal_int(obj1, &val2);
18469 if (!SWIG_IsOK(ecode2)) {
18470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18471 }
18472 arg2 = static_cast< int >(val2);
18473 {
18474 PyThreadState* __tstate = wxPyBeginAllowThreads();
18475 (arg1)->ResumePropagation(arg2);
18476 wxPyEndAllowThreads(__tstate);
18477 if (PyErr_Occurred()) SWIG_fail;
18478 }
18479 resultobj = SWIG_Py_Void();
18480 return resultobj;
18481 fail:
18482 return NULL;
18483 }
18484
18485
18486 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18487 PyObject *resultobj = 0;
18488 wxEvent *arg1 = (wxEvent *) 0 ;
18489 wxEvent *result = 0 ;
18490 void *argp1 = 0 ;
18491 int res1 = 0 ;
18492 PyObject *swig_obj[1] ;
18493
18494 if (!args) SWIG_fail;
18495 swig_obj[0] = args;
18496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18497 if (!SWIG_IsOK(res1)) {
18498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18499 }
18500 arg1 = reinterpret_cast< wxEvent * >(argp1);
18501 {
18502 PyThreadState* __tstate = wxPyBeginAllowThreads();
18503 result = (wxEvent *)(arg1)->Clone();
18504 wxPyEndAllowThreads(__tstate);
18505 if (PyErr_Occurred()) SWIG_fail;
18506 }
18507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18508 return resultobj;
18509 fail:
18510 return NULL;
18511 }
18512
18513
18514 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18515 PyObject *obj;
18516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18517 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18518 return SWIG_Py_Void();
18519 }
18520
18521 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18522 PyObject *resultobj = 0;
18523 wxEvent *arg1 = 0 ;
18524 wxPropagationDisabler *result = 0 ;
18525 void *argp1 = 0 ;
18526 int res1 = 0 ;
18527 PyObject * obj0 = 0 ;
18528 char * kwnames[] = {
18529 (char *) "event", NULL
18530 };
18531
18532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18533 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18534 if (!SWIG_IsOK(res1)) {
18535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18536 }
18537 if (!argp1) {
18538 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18539 }
18540 arg1 = reinterpret_cast< wxEvent * >(argp1);
18541 {
18542 PyThreadState* __tstate = wxPyBeginAllowThreads();
18543 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18544 wxPyEndAllowThreads(__tstate);
18545 if (PyErr_Occurred()) SWIG_fail;
18546 }
18547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18548 return resultobj;
18549 fail:
18550 return NULL;
18551 }
18552
18553
18554 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18555 PyObject *resultobj = 0;
18556 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18557 void *argp1 = 0 ;
18558 int res1 = 0 ;
18559 PyObject *swig_obj[1] ;
18560
18561 if (!args) SWIG_fail;
18562 swig_obj[0] = args;
18563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18564 if (!SWIG_IsOK(res1)) {
18565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18566 }
18567 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18568 {
18569 PyThreadState* __tstate = wxPyBeginAllowThreads();
18570 delete arg1;
18571
18572 wxPyEndAllowThreads(__tstate);
18573 if (PyErr_Occurred()) SWIG_fail;
18574 }
18575 resultobj = SWIG_Py_Void();
18576 return resultobj;
18577 fail:
18578 return NULL;
18579 }
18580
18581
18582 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18583 PyObject *obj;
18584 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18585 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18586 return SWIG_Py_Void();
18587 }
18588
18589 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18590 return SWIG_Python_InitShadowInstance(args);
18591 }
18592
18593 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18594 PyObject *resultobj = 0;
18595 wxEvent *arg1 = 0 ;
18596 wxPropagateOnce *result = 0 ;
18597 void *argp1 = 0 ;
18598 int res1 = 0 ;
18599 PyObject * obj0 = 0 ;
18600 char * kwnames[] = {
18601 (char *) "event", NULL
18602 };
18603
18604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18605 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18606 if (!SWIG_IsOK(res1)) {
18607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18608 }
18609 if (!argp1) {
18610 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18611 }
18612 arg1 = reinterpret_cast< wxEvent * >(argp1);
18613 {
18614 PyThreadState* __tstate = wxPyBeginAllowThreads();
18615 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18616 wxPyEndAllowThreads(__tstate);
18617 if (PyErr_Occurred()) SWIG_fail;
18618 }
18619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18620 return resultobj;
18621 fail:
18622 return NULL;
18623 }
18624
18625
18626 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18627 PyObject *resultobj = 0;
18628 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18629 void *argp1 = 0 ;
18630 int res1 = 0 ;
18631 PyObject *swig_obj[1] ;
18632
18633 if (!args) SWIG_fail;
18634 swig_obj[0] = args;
18635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18636 if (!SWIG_IsOK(res1)) {
18637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18638 }
18639 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18640 {
18641 PyThreadState* __tstate = wxPyBeginAllowThreads();
18642 delete arg1;
18643
18644 wxPyEndAllowThreads(__tstate);
18645 if (PyErr_Occurred()) SWIG_fail;
18646 }
18647 resultobj = SWIG_Py_Void();
18648 return resultobj;
18649 fail:
18650 return NULL;
18651 }
18652
18653
18654 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18655 PyObject *obj;
18656 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18657 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18658 return SWIG_Py_Void();
18659 }
18660
18661 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18662 return SWIG_Python_InitShadowInstance(args);
18663 }
18664
18665 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18666 PyObject *resultobj = 0;
18667 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18668 int arg2 = (int) 0 ;
18669 wxCommandEvent *result = 0 ;
18670 int val1 ;
18671 int ecode1 = 0 ;
18672 int val2 ;
18673 int ecode2 = 0 ;
18674 PyObject * obj0 = 0 ;
18675 PyObject * obj1 = 0 ;
18676 char * kwnames[] = {
18677 (char *) "commandType",(char *) "winid", NULL
18678 };
18679
18680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18681 if (obj0) {
18682 ecode1 = SWIG_AsVal_int(obj0, &val1);
18683 if (!SWIG_IsOK(ecode1)) {
18684 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18685 }
18686 arg1 = static_cast< wxEventType >(val1);
18687 }
18688 if (obj1) {
18689 ecode2 = SWIG_AsVal_int(obj1, &val2);
18690 if (!SWIG_IsOK(ecode2)) {
18691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18692 }
18693 arg2 = static_cast< int >(val2);
18694 }
18695 {
18696 PyThreadState* __tstate = wxPyBeginAllowThreads();
18697 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18698 wxPyEndAllowThreads(__tstate);
18699 if (PyErr_Occurred()) SWIG_fail;
18700 }
18701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18702 return resultobj;
18703 fail:
18704 return NULL;
18705 }
18706
18707
18708 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18709 PyObject *resultobj = 0;
18710 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18711 int result;
18712 void *argp1 = 0 ;
18713 int res1 = 0 ;
18714 PyObject *swig_obj[1] ;
18715
18716 if (!args) SWIG_fail;
18717 swig_obj[0] = args;
18718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18719 if (!SWIG_IsOK(res1)) {
18720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18721 }
18722 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18723 {
18724 PyThreadState* __tstate = wxPyBeginAllowThreads();
18725 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18726 wxPyEndAllowThreads(__tstate);
18727 if (PyErr_Occurred()) SWIG_fail;
18728 }
18729 resultobj = SWIG_From_int(static_cast< int >(result));
18730 return resultobj;
18731 fail:
18732 return NULL;
18733 }
18734
18735
18736 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18737 PyObject *resultobj = 0;
18738 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18739 wxString *arg2 = 0 ;
18740 void *argp1 = 0 ;
18741 int res1 = 0 ;
18742 bool temp2 = false ;
18743 PyObject * obj0 = 0 ;
18744 PyObject * obj1 = 0 ;
18745 char * kwnames[] = {
18746 (char *) "self",(char *) "s", NULL
18747 };
18748
18749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18751 if (!SWIG_IsOK(res1)) {
18752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18753 }
18754 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18755 {
18756 arg2 = wxString_in_helper(obj1);
18757 if (arg2 == NULL) SWIG_fail;
18758 temp2 = true;
18759 }
18760 {
18761 PyThreadState* __tstate = wxPyBeginAllowThreads();
18762 (arg1)->SetString((wxString const &)*arg2);
18763 wxPyEndAllowThreads(__tstate);
18764 if (PyErr_Occurred()) SWIG_fail;
18765 }
18766 resultobj = SWIG_Py_Void();
18767 {
18768 if (temp2)
18769 delete arg2;
18770 }
18771 return resultobj;
18772 fail:
18773 {
18774 if (temp2)
18775 delete arg2;
18776 }
18777 return NULL;
18778 }
18779
18780
18781 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18782 PyObject *resultobj = 0;
18783 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18784 wxString result;
18785 void *argp1 = 0 ;
18786 int res1 = 0 ;
18787 PyObject *swig_obj[1] ;
18788
18789 if (!args) SWIG_fail;
18790 swig_obj[0] = args;
18791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18792 if (!SWIG_IsOK(res1)) {
18793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18794 }
18795 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18796 {
18797 PyThreadState* __tstate = wxPyBeginAllowThreads();
18798 result = ((wxCommandEvent const *)arg1)->GetString();
18799 wxPyEndAllowThreads(__tstate);
18800 if (PyErr_Occurred()) SWIG_fail;
18801 }
18802 {
18803 #if wxUSE_UNICODE
18804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18805 #else
18806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18807 #endif
18808 }
18809 return resultobj;
18810 fail:
18811 return NULL;
18812 }
18813
18814
18815 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18816 PyObject *resultobj = 0;
18817 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18818 bool result;
18819 void *argp1 = 0 ;
18820 int res1 = 0 ;
18821 PyObject *swig_obj[1] ;
18822
18823 if (!args) SWIG_fail;
18824 swig_obj[0] = args;
18825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18826 if (!SWIG_IsOK(res1)) {
18827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18828 }
18829 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18833 wxPyEndAllowThreads(__tstate);
18834 if (PyErr_Occurred()) SWIG_fail;
18835 }
18836 {
18837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18838 }
18839 return resultobj;
18840 fail:
18841 return NULL;
18842 }
18843
18844
18845 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18846 PyObject *resultobj = 0;
18847 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18848 bool result;
18849 void *argp1 = 0 ;
18850 int res1 = 0 ;
18851 PyObject *swig_obj[1] ;
18852
18853 if (!args) SWIG_fail;
18854 swig_obj[0] = args;
18855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18856 if (!SWIG_IsOK(res1)) {
18857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18858 }
18859 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18860 {
18861 PyThreadState* __tstate = wxPyBeginAllowThreads();
18862 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18863 wxPyEndAllowThreads(__tstate);
18864 if (PyErr_Occurred()) SWIG_fail;
18865 }
18866 {
18867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18868 }
18869 return resultobj;
18870 fail:
18871 return NULL;
18872 }
18873
18874
18875 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18876 PyObject *resultobj = 0;
18877 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18878 long arg2 ;
18879 void *argp1 = 0 ;
18880 int res1 = 0 ;
18881 long val2 ;
18882 int ecode2 = 0 ;
18883 PyObject * obj0 = 0 ;
18884 PyObject * obj1 = 0 ;
18885 char * kwnames[] = {
18886 (char *) "self",(char *) "extraLong", NULL
18887 };
18888
18889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18891 if (!SWIG_IsOK(res1)) {
18892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18893 }
18894 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18895 ecode2 = SWIG_AsVal_long(obj1, &val2);
18896 if (!SWIG_IsOK(ecode2)) {
18897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
18898 }
18899 arg2 = static_cast< long >(val2);
18900 {
18901 PyThreadState* __tstate = wxPyBeginAllowThreads();
18902 (arg1)->SetExtraLong(arg2);
18903 wxPyEndAllowThreads(__tstate);
18904 if (PyErr_Occurred()) SWIG_fail;
18905 }
18906 resultobj = SWIG_Py_Void();
18907 return resultobj;
18908 fail:
18909 return NULL;
18910 }
18911
18912
18913 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18914 PyObject *resultobj = 0;
18915 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18916 long result;
18917 void *argp1 = 0 ;
18918 int res1 = 0 ;
18919 PyObject *swig_obj[1] ;
18920
18921 if (!args) SWIG_fail;
18922 swig_obj[0] = args;
18923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18924 if (!SWIG_IsOK(res1)) {
18925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18926 }
18927 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18928 {
18929 PyThreadState* __tstate = wxPyBeginAllowThreads();
18930 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
18931 wxPyEndAllowThreads(__tstate);
18932 if (PyErr_Occurred()) SWIG_fail;
18933 }
18934 resultobj = SWIG_From_long(static_cast< long >(result));
18935 return resultobj;
18936 fail:
18937 return NULL;
18938 }
18939
18940
18941 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18942 PyObject *resultobj = 0;
18943 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18944 int arg2 ;
18945 void *argp1 = 0 ;
18946 int res1 = 0 ;
18947 int val2 ;
18948 int ecode2 = 0 ;
18949 PyObject * obj0 = 0 ;
18950 PyObject * obj1 = 0 ;
18951 char * kwnames[] = {
18952 (char *) "self",(char *) "i", NULL
18953 };
18954
18955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
18956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18957 if (!SWIG_IsOK(res1)) {
18958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18959 }
18960 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18961 ecode2 = SWIG_AsVal_int(obj1, &val2);
18962 if (!SWIG_IsOK(ecode2)) {
18963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
18964 }
18965 arg2 = static_cast< int >(val2);
18966 {
18967 PyThreadState* __tstate = wxPyBeginAllowThreads();
18968 (arg1)->SetInt(arg2);
18969 wxPyEndAllowThreads(__tstate);
18970 if (PyErr_Occurred()) SWIG_fail;
18971 }
18972 resultobj = SWIG_Py_Void();
18973 return resultobj;
18974 fail:
18975 return NULL;
18976 }
18977
18978
18979 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18980 PyObject *resultobj = 0;
18981 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18982 long result;
18983 void *argp1 = 0 ;
18984 int res1 = 0 ;
18985 PyObject *swig_obj[1] ;
18986
18987 if (!args) SWIG_fail;
18988 swig_obj[0] = args;
18989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18990 if (!SWIG_IsOK(res1)) {
18991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18992 }
18993 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18994 {
18995 PyThreadState* __tstate = wxPyBeginAllowThreads();
18996 result = (long)((wxCommandEvent const *)arg1)->GetInt();
18997 wxPyEndAllowThreads(__tstate);
18998 if (PyErr_Occurred()) SWIG_fail;
18999 }
19000 resultobj = SWIG_From_long(static_cast< long >(result));
19001 return resultobj;
19002 fail:
19003 return NULL;
19004 }
19005
19006
19007 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19008 PyObject *resultobj = 0;
19009 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19010 PyObject *result = 0 ;
19011 void *argp1 = 0 ;
19012 int res1 = 0 ;
19013 PyObject *swig_obj[1] ;
19014
19015 if (!args) SWIG_fail;
19016 swig_obj[0] = args;
19017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19018 if (!SWIG_IsOK(res1)) {
19019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19020 }
19021 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19022 {
19023 PyThreadState* __tstate = wxPyBeginAllowThreads();
19024 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19025 wxPyEndAllowThreads(__tstate);
19026 if (PyErr_Occurred()) SWIG_fail;
19027 }
19028 resultobj = result;
19029 return resultobj;
19030 fail:
19031 return NULL;
19032 }
19033
19034
19035 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19036 PyObject *resultobj = 0;
19037 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19038 PyObject *arg2 = (PyObject *) 0 ;
19039 void *argp1 = 0 ;
19040 int res1 = 0 ;
19041 PyObject * obj0 = 0 ;
19042 PyObject * obj1 = 0 ;
19043 char * kwnames[] = {
19044 (char *) "self",(char *) "clientData", NULL
19045 };
19046
19047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19049 if (!SWIG_IsOK(res1)) {
19050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19051 }
19052 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19053 arg2 = obj1;
19054 {
19055 PyThreadState* __tstate = wxPyBeginAllowThreads();
19056 wxCommandEvent_SetClientData(arg1,arg2);
19057 wxPyEndAllowThreads(__tstate);
19058 if (PyErr_Occurred()) SWIG_fail;
19059 }
19060 resultobj = SWIG_Py_Void();
19061 return resultobj;
19062 fail:
19063 return NULL;
19064 }
19065
19066
19067 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19068 PyObject *resultobj = 0;
19069 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19070 wxEvent *result = 0 ;
19071 void *argp1 = 0 ;
19072 int res1 = 0 ;
19073 PyObject *swig_obj[1] ;
19074
19075 if (!args) SWIG_fail;
19076 swig_obj[0] = args;
19077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19078 if (!SWIG_IsOK(res1)) {
19079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19080 }
19081 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19082 {
19083 PyThreadState* __tstate = wxPyBeginAllowThreads();
19084 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19085 wxPyEndAllowThreads(__tstate);
19086 if (PyErr_Occurred()) SWIG_fail;
19087 }
19088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19089 return resultobj;
19090 fail:
19091 return NULL;
19092 }
19093
19094
19095 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19096 PyObject *obj;
19097 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19098 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19099 return SWIG_Py_Void();
19100 }
19101
19102 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19103 return SWIG_Python_InitShadowInstance(args);
19104 }
19105
19106 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19107 PyObject *resultobj = 0;
19108 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19109 int arg2 = (int) 0 ;
19110 wxNotifyEvent *result = 0 ;
19111 int val1 ;
19112 int ecode1 = 0 ;
19113 int val2 ;
19114 int ecode2 = 0 ;
19115 PyObject * obj0 = 0 ;
19116 PyObject * obj1 = 0 ;
19117 char * kwnames[] = {
19118 (char *) "commandType",(char *) "winid", NULL
19119 };
19120
19121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19122 if (obj0) {
19123 ecode1 = SWIG_AsVal_int(obj0, &val1);
19124 if (!SWIG_IsOK(ecode1)) {
19125 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19126 }
19127 arg1 = static_cast< wxEventType >(val1);
19128 }
19129 if (obj1) {
19130 ecode2 = SWIG_AsVal_int(obj1, &val2);
19131 if (!SWIG_IsOK(ecode2)) {
19132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19133 }
19134 arg2 = static_cast< int >(val2);
19135 }
19136 {
19137 PyThreadState* __tstate = wxPyBeginAllowThreads();
19138 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19139 wxPyEndAllowThreads(__tstate);
19140 if (PyErr_Occurred()) SWIG_fail;
19141 }
19142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19143 return resultobj;
19144 fail:
19145 return NULL;
19146 }
19147
19148
19149 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19150 PyObject *resultobj = 0;
19151 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19152 void *argp1 = 0 ;
19153 int res1 = 0 ;
19154 PyObject *swig_obj[1] ;
19155
19156 if (!args) SWIG_fail;
19157 swig_obj[0] = args;
19158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19159 if (!SWIG_IsOK(res1)) {
19160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19161 }
19162 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19163 {
19164 PyThreadState* __tstate = wxPyBeginAllowThreads();
19165 (arg1)->Veto();
19166 wxPyEndAllowThreads(__tstate);
19167 if (PyErr_Occurred()) SWIG_fail;
19168 }
19169 resultobj = SWIG_Py_Void();
19170 return resultobj;
19171 fail:
19172 return NULL;
19173 }
19174
19175
19176 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19177 PyObject *resultobj = 0;
19178 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19179 void *argp1 = 0 ;
19180 int res1 = 0 ;
19181 PyObject *swig_obj[1] ;
19182
19183 if (!args) SWIG_fail;
19184 swig_obj[0] = args;
19185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19186 if (!SWIG_IsOK(res1)) {
19187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19188 }
19189 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19190 {
19191 PyThreadState* __tstate = wxPyBeginAllowThreads();
19192 (arg1)->Allow();
19193 wxPyEndAllowThreads(__tstate);
19194 if (PyErr_Occurred()) SWIG_fail;
19195 }
19196 resultobj = SWIG_Py_Void();
19197 return resultobj;
19198 fail:
19199 return NULL;
19200 }
19201
19202
19203 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19204 PyObject *resultobj = 0;
19205 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19206 bool result;
19207 void *argp1 = 0 ;
19208 int res1 = 0 ;
19209 PyObject *swig_obj[1] ;
19210
19211 if (!args) SWIG_fail;
19212 swig_obj[0] = args;
19213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19214 if (!SWIG_IsOK(res1)) {
19215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19216 }
19217 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19218 {
19219 PyThreadState* __tstate = wxPyBeginAllowThreads();
19220 result = (bool)(arg1)->IsAllowed();
19221 wxPyEndAllowThreads(__tstate);
19222 if (PyErr_Occurred()) SWIG_fail;
19223 }
19224 {
19225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19226 }
19227 return resultobj;
19228 fail:
19229 return NULL;
19230 }
19231
19232
19233 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19234 PyObject *obj;
19235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19236 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19237 return SWIG_Py_Void();
19238 }
19239
19240 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19241 return SWIG_Python_InitShadowInstance(args);
19242 }
19243
19244 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19245 PyObject *resultobj = 0;
19246 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19247 int arg2 = (int) 0 ;
19248 int arg3 = (int) 0 ;
19249 int arg4 = (int) 0 ;
19250 wxScrollEvent *result = 0 ;
19251 int val1 ;
19252 int ecode1 = 0 ;
19253 int val2 ;
19254 int ecode2 = 0 ;
19255 int val3 ;
19256 int ecode3 = 0 ;
19257 int val4 ;
19258 int ecode4 = 0 ;
19259 PyObject * obj0 = 0 ;
19260 PyObject * obj1 = 0 ;
19261 PyObject * obj2 = 0 ;
19262 PyObject * obj3 = 0 ;
19263 char * kwnames[] = {
19264 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19265 };
19266
19267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19268 if (obj0) {
19269 ecode1 = SWIG_AsVal_int(obj0, &val1);
19270 if (!SWIG_IsOK(ecode1)) {
19271 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19272 }
19273 arg1 = static_cast< wxEventType >(val1);
19274 }
19275 if (obj1) {
19276 ecode2 = SWIG_AsVal_int(obj1, &val2);
19277 if (!SWIG_IsOK(ecode2)) {
19278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19279 }
19280 arg2 = static_cast< int >(val2);
19281 }
19282 if (obj2) {
19283 ecode3 = SWIG_AsVal_int(obj2, &val3);
19284 if (!SWIG_IsOK(ecode3)) {
19285 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19286 }
19287 arg3 = static_cast< int >(val3);
19288 }
19289 if (obj3) {
19290 ecode4 = SWIG_AsVal_int(obj3, &val4);
19291 if (!SWIG_IsOK(ecode4)) {
19292 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19293 }
19294 arg4 = static_cast< int >(val4);
19295 }
19296 {
19297 PyThreadState* __tstate = wxPyBeginAllowThreads();
19298 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19299 wxPyEndAllowThreads(__tstate);
19300 if (PyErr_Occurred()) SWIG_fail;
19301 }
19302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19303 return resultobj;
19304 fail:
19305 return NULL;
19306 }
19307
19308
19309 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19310 PyObject *resultobj = 0;
19311 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19312 int result;
19313 void *argp1 = 0 ;
19314 int res1 = 0 ;
19315 PyObject *swig_obj[1] ;
19316
19317 if (!args) SWIG_fail;
19318 swig_obj[0] = args;
19319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19320 if (!SWIG_IsOK(res1)) {
19321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19322 }
19323 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19324 {
19325 PyThreadState* __tstate = wxPyBeginAllowThreads();
19326 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19327 wxPyEndAllowThreads(__tstate);
19328 if (PyErr_Occurred()) SWIG_fail;
19329 }
19330 resultobj = SWIG_From_int(static_cast< int >(result));
19331 return resultobj;
19332 fail:
19333 return NULL;
19334 }
19335
19336
19337 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19338 PyObject *resultobj = 0;
19339 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19340 int result;
19341 void *argp1 = 0 ;
19342 int res1 = 0 ;
19343 PyObject *swig_obj[1] ;
19344
19345 if (!args) SWIG_fail;
19346 swig_obj[0] = args;
19347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19348 if (!SWIG_IsOK(res1)) {
19349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19350 }
19351 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19352 {
19353 PyThreadState* __tstate = wxPyBeginAllowThreads();
19354 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19355 wxPyEndAllowThreads(__tstate);
19356 if (PyErr_Occurred()) SWIG_fail;
19357 }
19358 resultobj = SWIG_From_int(static_cast< int >(result));
19359 return resultobj;
19360 fail:
19361 return NULL;
19362 }
19363
19364
19365 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19366 PyObject *resultobj = 0;
19367 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19368 int arg2 ;
19369 void *argp1 = 0 ;
19370 int res1 = 0 ;
19371 int val2 ;
19372 int ecode2 = 0 ;
19373 PyObject * obj0 = 0 ;
19374 PyObject * obj1 = 0 ;
19375 char * kwnames[] = {
19376 (char *) "self",(char *) "orient", NULL
19377 };
19378
19379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19381 if (!SWIG_IsOK(res1)) {
19382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19383 }
19384 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19385 ecode2 = SWIG_AsVal_int(obj1, &val2);
19386 if (!SWIG_IsOK(ecode2)) {
19387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19388 }
19389 arg2 = static_cast< int >(val2);
19390 {
19391 PyThreadState* __tstate = wxPyBeginAllowThreads();
19392 (arg1)->SetOrientation(arg2);
19393 wxPyEndAllowThreads(__tstate);
19394 if (PyErr_Occurred()) SWIG_fail;
19395 }
19396 resultobj = SWIG_Py_Void();
19397 return resultobj;
19398 fail:
19399 return NULL;
19400 }
19401
19402
19403 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19404 PyObject *resultobj = 0;
19405 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19406 int arg2 ;
19407 void *argp1 = 0 ;
19408 int res1 = 0 ;
19409 int val2 ;
19410 int ecode2 = 0 ;
19411 PyObject * obj0 = 0 ;
19412 PyObject * obj1 = 0 ;
19413 char * kwnames[] = {
19414 (char *) "self",(char *) "pos", NULL
19415 };
19416
19417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19419 if (!SWIG_IsOK(res1)) {
19420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19421 }
19422 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19423 ecode2 = SWIG_AsVal_int(obj1, &val2);
19424 if (!SWIG_IsOK(ecode2)) {
19425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19426 }
19427 arg2 = static_cast< int >(val2);
19428 {
19429 PyThreadState* __tstate = wxPyBeginAllowThreads();
19430 (arg1)->SetPosition(arg2);
19431 wxPyEndAllowThreads(__tstate);
19432 if (PyErr_Occurred()) SWIG_fail;
19433 }
19434 resultobj = SWIG_Py_Void();
19435 return resultobj;
19436 fail:
19437 return NULL;
19438 }
19439
19440
19441 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19442 PyObject *obj;
19443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19444 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19445 return SWIG_Py_Void();
19446 }
19447
19448 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19449 return SWIG_Python_InitShadowInstance(args);
19450 }
19451
19452 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19453 PyObject *resultobj = 0;
19454 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19455 int arg2 = (int) 0 ;
19456 int arg3 = (int) 0 ;
19457 wxScrollWinEvent *result = 0 ;
19458 int val1 ;
19459 int ecode1 = 0 ;
19460 int val2 ;
19461 int ecode2 = 0 ;
19462 int val3 ;
19463 int ecode3 = 0 ;
19464 PyObject * obj0 = 0 ;
19465 PyObject * obj1 = 0 ;
19466 PyObject * obj2 = 0 ;
19467 char * kwnames[] = {
19468 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19469 };
19470
19471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19472 if (obj0) {
19473 ecode1 = SWIG_AsVal_int(obj0, &val1);
19474 if (!SWIG_IsOK(ecode1)) {
19475 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19476 }
19477 arg1 = static_cast< wxEventType >(val1);
19478 }
19479 if (obj1) {
19480 ecode2 = SWIG_AsVal_int(obj1, &val2);
19481 if (!SWIG_IsOK(ecode2)) {
19482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19483 }
19484 arg2 = static_cast< int >(val2);
19485 }
19486 if (obj2) {
19487 ecode3 = SWIG_AsVal_int(obj2, &val3);
19488 if (!SWIG_IsOK(ecode3)) {
19489 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19490 }
19491 arg3 = static_cast< int >(val3);
19492 }
19493 {
19494 PyThreadState* __tstate = wxPyBeginAllowThreads();
19495 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19496 wxPyEndAllowThreads(__tstate);
19497 if (PyErr_Occurred()) SWIG_fail;
19498 }
19499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19500 return resultobj;
19501 fail:
19502 return NULL;
19503 }
19504
19505
19506 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19507 PyObject *resultobj = 0;
19508 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19509 int result;
19510 void *argp1 = 0 ;
19511 int res1 = 0 ;
19512 PyObject *swig_obj[1] ;
19513
19514 if (!args) SWIG_fail;
19515 swig_obj[0] = args;
19516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19517 if (!SWIG_IsOK(res1)) {
19518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19519 }
19520 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19521 {
19522 PyThreadState* __tstate = wxPyBeginAllowThreads();
19523 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19524 wxPyEndAllowThreads(__tstate);
19525 if (PyErr_Occurred()) SWIG_fail;
19526 }
19527 resultobj = SWIG_From_int(static_cast< int >(result));
19528 return resultobj;
19529 fail:
19530 return NULL;
19531 }
19532
19533
19534 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19535 PyObject *resultobj = 0;
19536 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19537 int result;
19538 void *argp1 = 0 ;
19539 int res1 = 0 ;
19540 PyObject *swig_obj[1] ;
19541
19542 if (!args) SWIG_fail;
19543 swig_obj[0] = args;
19544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19545 if (!SWIG_IsOK(res1)) {
19546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19547 }
19548 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19549 {
19550 PyThreadState* __tstate = wxPyBeginAllowThreads();
19551 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19552 wxPyEndAllowThreads(__tstate);
19553 if (PyErr_Occurred()) SWIG_fail;
19554 }
19555 resultobj = SWIG_From_int(static_cast< int >(result));
19556 return resultobj;
19557 fail:
19558 return NULL;
19559 }
19560
19561
19562 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19563 PyObject *resultobj = 0;
19564 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19565 int arg2 ;
19566 void *argp1 = 0 ;
19567 int res1 = 0 ;
19568 int val2 ;
19569 int ecode2 = 0 ;
19570 PyObject * obj0 = 0 ;
19571 PyObject * obj1 = 0 ;
19572 char * kwnames[] = {
19573 (char *) "self",(char *) "orient", NULL
19574 };
19575
19576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19578 if (!SWIG_IsOK(res1)) {
19579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19580 }
19581 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19582 ecode2 = SWIG_AsVal_int(obj1, &val2);
19583 if (!SWIG_IsOK(ecode2)) {
19584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19585 }
19586 arg2 = static_cast< int >(val2);
19587 {
19588 PyThreadState* __tstate = wxPyBeginAllowThreads();
19589 (arg1)->SetOrientation(arg2);
19590 wxPyEndAllowThreads(__tstate);
19591 if (PyErr_Occurred()) SWIG_fail;
19592 }
19593 resultobj = SWIG_Py_Void();
19594 return resultobj;
19595 fail:
19596 return NULL;
19597 }
19598
19599
19600 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19601 PyObject *resultobj = 0;
19602 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19603 int arg2 ;
19604 void *argp1 = 0 ;
19605 int res1 = 0 ;
19606 int val2 ;
19607 int ecode2 = 0 ;
19608 PyObject * obj0 = 0 ;
19609 PyObject * obj1 = 0 ;
19610 char * kwnames[] = {
19611 (char *) "self",(char *) "pos", NULL
19612 };
19613
19614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19616 if (!SWIG_IsOK(res1)) {
19617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19618 }
19619 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19620 ecode2 = SWIG_AsVal_int(obj1, &val2);
19621 if (!SWIG_IsOK(ecode2)) {
19622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19623 }
19624 arg2 = static_cast< int >(val2);
19625 {
19626 PyThreadState* __tstate = wxPyBeginAllowThreads();
19627 (arg1)->SetPosition(arg2);
19628 wxPyEndAllowThreads(__tstate);
19629 if (PyErr_Occurred()) SWIG_fail;
19630 }
19631 resultobj = SWIG_Py_Void();
19632 return resultobj;
19633 fail:
19634 return NULL;
19635 }
19636
19637
19638 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19639 PyObject *obj;
19640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19641 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19642 return SWIG_Py_Void();
19643 }
19644
19645 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19646 return SWIG_Python_InitShadowInstance(args);
19647 }
19648
19649 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19650 PyObject *resultobj = 0;
19651 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19652 wxMouseEvent *result = 0 ;
19653 int val1 ;
19654 int ecode1 = 0 ;
19655 PyObject * obj0 = 0 ;
19656 char * kwnames[] = {
19657 (char *) "mouseType", NULL
19658 };
19659
19660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19661 if (obj0) {
19662 ecode1 = SWIG_AsVal_int(obj0, &val1);
19663 if (!SWIG_IsOK(ecode1)) {
19664 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19665 }
19666 arg1 = static_cast< wxEventType >(val1);
19667 }
19668 {
19669 PyThreadState* __tstate = wxPyBeginAllowThreads();
19670 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19671 wxPyEndAllowThreads(__tstate);
19672 if (PyErr_Occurred()) SWIG_fail;
19673 }
19674 {
19675 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19676 }
19677 return resultobj;
19678 fail:
19679 return NULL;
19680 }
19681
19682
19683 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19684 PyObject *resultobj = 0;
19685 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19686 bool result;
19687 void *argp1 = 0 ;
19688 int res1 = 0 ;
19689 PyObject *swig_obj[1] ;
19690
19691 if (!args) SWIG_fail;
19692 swig_obj[0] = args;
19693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19694 if (!SWIG_IsOK(res1)) {
19695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19696 }
19697 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19698 {
19699 PyThreadState* __tstate = wxPyBeginAllowThreads();
19700 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19701 wxPyEndAllowThreads(__tstate);
19702 if (PyErr_Occurred()) SWIG_fail;
19703 }
19704 {
19705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19706 }
19707 return resultobj;
19708 fail:
19709 return NULL;
19710 }
19711
19712
19713 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19714 PyObject *resultobj = 0;
19715 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19716 int arg2 = (int) wxMOUSE_BTN_ANY ;
19717 bool result;
19718 void *argp1 = 0 ;
19719 int res1 = 0 ;
19720 int val2 ;
19721 int ecode2 = 0 ;
19722 PyObject * obj0 = 0 ;
19723 PyObject * obj1 = 0 ;
19724 char * kwnames[] = {
19725 (char *) "self",(char *) "but", NULL
19726 };
19727
19728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19730 if (!SWIG_IsOK(res1)) {
19731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19732 }
19733 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19734 if (obj1) {
19735 ecode2 = SWIG_AsVal_int(obj1, &val2);
19736 if (!SWIG_IsOK(ecode2)) {
19737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19738 }
19739 arg2 = static_cast< int >(val2);
19740 }
19741 {
19742 PyThreadState* __tstate = wxPyBeginAllowThreads();
19743 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19744 wxPyEndAllowThreads(__tstate);
19745 if (PyErr_Occurred()) SWIG_fail;
19746 }
19747 {
19748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19749 }
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19757 PyObject *resultobj = 0;
19758 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19759 int arg2 = (int) wxMOUSE_BTN_ANY ;
19760 bool result;
19761 void *argp1 = 0 ;
19762 int res1 = 0 ;
19763 int val2 ;
19764 int ecode2 = 0 ;
19765 PyObject * obj0 = 0 ;
19766 PyObject * obj1 = 0 ;
19767 char * kwnames[] = {
19768 (char *) "self",(char *) "but", NULL
19769 };
19770
19771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19773 if (!SWIG_IsOK(res1)) {
19774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19775 }
19776 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19777 if (obj1) {
19778 ecode2 = SWIG_AsVal_int(obj1, &val2);
19779 if (!SWIG_IsOK(ecode2)) {
19780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19781 }
19782 arg2 = static_cast< int >(val2);
19783 }
19784 {
19785 PyThreadState* __tstate = wxPyBeginAllowThreads();
19786 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19787 wxPyEndAllowThreads(__tstate);
19788 if (PyErr_Occurred()) SWIG_fail;
19789 }
19790 {
19791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19792 }
19793 return resultobj;
19794 fail:
19795 return NULL;
19796 }
19797
19798
19799 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19800 PyObject *resultobj = 0;
19801 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19802 int arg2 = (int) wxMOUSE_BTN_ANY ;
19803 bool result;
19804 void *argp1 = 0 ;
19805 int res1 = 0 ;
19806 int val2 ;
19807 int ecode2 = 0 ;
19808 PyObject * obj0 = 0 ;
19809 PyObject * obj1 = 0 ;
19810 char * kwnames[] = {
19811 (char *) "self",(char *) "but", NULL
19812 };
19813
19814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19816 if (!SWIG_IsOK(res1)) {
19817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19818 }
19819 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19820 if (obj1) {
19821 ecode2 = SWIG_AsVal_int(obj1, &val2);
19822 if (!SWIG_IsOK(ecode2)) {
19823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19824 }
19825 arg2 = static_cast< int >(val2);
19826 }
19827 {
19828 PyThreadState* __tstate = wxPyBeginAllowThreads();
19829 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19830 wxPyEndAllowThreads(__tstate);
19831 if (PyErr_Occurred()) SWIG_fail;
19832 }
19833 {
19834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19835 }
19836 return resultobj;
19837 fail:
19838 return NULL;
19839 }
19840
19841
19842 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19843 PyObject *resultobj = 0;
19844 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19845 int arg2 ;
19846 bool result;
19847 void *argp1 = 0 ;
19848 int res1 = 0 ;
19849 int val2 ;
19850 int ecode2 = 0 ;
19851 PyObject * obj0 = 0 ;
19852 PyObject * obj1 = 0 ;
19853 char * kwnames[] = {
19854 (char *) "self",(char *) "button", NULL
19855 };
19856
19857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19859 if (!SWIG_IsOK(res1)) {
19860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19861 }
19862 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19863 ecode2 = SWIG_AsVal_int(obj1, &val2);
19864 if (!SWIG_IsOK(ecode2)) {
19865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19866 }
19867 arg2 = static_cast< int >(val2);
19868 {
19869 PyThreadState* __tstate = wxPyBeginAllowThreads();
19870 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
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_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19884 PyObject *resultobj = 0;
19885 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19886 int arg2 ;
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 *)"OO:MouseEvent_ButtonIsDown",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_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19902 }
19903 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19904 ecode2 = SWIG_AsVal_int(obj1, &val2);
19905 if (!SWIG_IsOK(ecode2)) {
19906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
19907 }
19908 arg2 = static_cast< int >(val2);
19909 {
19910 PyThreadState* __tstate = wxPyBeginAllowThreads();
19911 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
19912 wxPyEndAllowThreads(__tstate);
19913 if (PyErr_Occurred()) SWIG_fail;
19914 }
19915 {
19916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19917 }
19918 return resultobj;
19919 fail:
19920 return NULL;
19921 }
19922
19923
19924 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19925 PyObject *resultobj = 0;
19926 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19927 int result;
19928 void *argp1 = 0 ;
19929 int res1 = 0 ;
19930 PyObject *swig_obj[1] ;
19931
19932 if (!args) SWIG_fail;
19933 swig_obj[0] = args;
19934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19935 if (!SWIG_IsOK(res1)) {
19936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19937 }
19938 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19939 {
19940 PyThreadState* __tstate = wxPyBeginAllowThreads();
19941 result = (int)((wxMouseEvent const *)arg1)->GetButton();
19942 wxPyEndAllowThreads(__tstate);
19943 if (PyErr_Occurred()) SWIG_fail;
19944 }
19945 resultobj = SWIG_From_int(static_cast< int >(result));
19946 return resultobj;
19947 fail:
19948 return NULL;
19949 }
19950
19951
19952 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19953 PyObject *resultobj = 0;
19954 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19955 bool result;
19956 void *argp1 = 0 ;
19957 int res1 = 0 ;
19958 PyObject *swig_obj[1] ;
19959
19960 if (!args) SWIG_fail;
19961 swig_obj[0] = args;
19962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19963 if (!SWIG_IsOK(res1)) {
19964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19965 }
19966 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19967 {
19968 PyThreadState* __tstate = wxPyBeginAllowThreads();
19969 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
19970 wxPyEndAllowThreads(__tstate);
19971 if (PyErr_Occurred()) SWIG_fail;
19972 }
19973 {
19974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19975 }
19976 return resultobj;
19977 fail:
19978 return NULL;
19979 }
19980
19981
19982 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19983 PyObject *resultobj = 0;
19984 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19985 bool result;
19986 void *argp1 = 0 ;
19987 int res1 = 0 ;
19988 PyObject *swig_obj[1] ;
19989
19990 if (!args) SWIG_fail;
19991 swig_obj[0] = args;
19992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19993 if (!SWIG_IsOK(res1)) {
19994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19995 }
19996 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19997 {
19998 PyThreadState* __tstate = wxPyBeginAllowThreads();
19999 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
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_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20013 PyObject *resultobj = 0;
20014 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20015 bool result;
20016 void *argp1 = 0 ;
20017 int res1 = 0 ;
20018 PyObject *swig_obj[1] ;
20019
20020 if (!args) SWIG_fail;
20021 swig_obj[0] = args;
20022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20023 if (!SWIG_IsOK(res1)) {
20024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20025 }
20026 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20027 {
20028 PyThreadState* __tstate = wxPyBeginAllowThreads();
20029 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20030 wxPyEndAllowThreads(__tstate);
20031 if (PyErr_Occurred()) SWIG_fail;
20032 }
20033 {
20034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20035 }
20036 return resultobj;
20037 fail:
20038 return NULL;
20039 }
20040
20041
20042 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20043 PyObject *resultobj = 0;
20044 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20045 bool result;
20046 void *argp1 = 0 ;
20047 int res1 = 0 ;
20048 PyObject *swig_obj[1] ;
20049
20050 if (!args) SWIG_fail;
20051 swig_obj[0] = args;
20052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20053 if (!SWIG_IsOK(res1)) {
20054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20055 }
20056 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20057 {
20058 PyThreadState* __tstate = wxPyBeginAllowThreads();
20059 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20060 wxPyEndAllowThreads(__tstate);
20061 if (PyErr_Occurred()) SWIG_fail;
20062 }
20063 {
20064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20065 }
20066 return resultobj;
20067 fail:
20068 return NULL;
20069 }
20070
20071
20072 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20073 PyObject *resultobj = 0;
20074 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20075 bool result;
20076 void *argp1 = 0 ;
20077 int res1 = 0 ;
20078 PyObject *swig_obj[1] ;
20079
20080 if (!args) SWIG_fail;
20081 swig_obj[0] = args;
20082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20083 if (!SWIG_IsOK(res1)) {
20084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20085 }
20086 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20087 {
20088 PyThreadState* __tstate = wxPyBeginAllowThreads();
20089 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20090 wxPyEndAllowThreads(__tstate);
20091 if (PyErr_Occurred()) SWIG_fail;
20092 }
20093 {
20094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20095 }
20096 return resultobj;
20097 fail:
20098 return NULL;
20099 }
20100
20101
20102 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20103 PyObject *resultobj = 0;
20104 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20105 bool result;
20106 void *argp1 = 0 ;
20107 int res1 = 0 ;
20108 PyObject *swig_obj[1] ;
20109
20110 if (!args) SWIG_fail;
20111 swig_obj[0] = args;
20112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20113 if (!SWIG_IsOK(res1)) {
20114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20115 }
20116 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20117 {
20118 PyThreadState* __tstate = wxPyBeginAllowThreads();
20119 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20120 wxPyEndAllowThreads(__tstate);
20121 if (PyErr_Occurred()) SWIG_fail;
20122 }
20123 {
20124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20125 }
20126 return resultobj;
20127 fail:
20128 return NULL;
20129 }
20130
20131
20132 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20133 PyObject *resultobj = 0;
20134 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20135 bool result;
20136 void *argp1 = 0 ;
20137 int res1 = 0 ;
20138 PyObject *swig_obj[1] ;
20139
20140 if (!args) SWIG_fail;
20141 swig_obj[0] = args;
20142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20143 if (!SWIG_IsOK(res1)) {
20144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20145 }
20146 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20147 {
20148 PyThreadState* __tstate = wxPyBeginAllowThreads();
20149 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20150 wxPyEndAllowThreads(__tstate);
20151 if (PyErr_Occurred()) SWIG_fail;
20152 }
20153 {
20154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20155 }
20156 return resultobj;
20157 fail:
20158 return NULL;
20159 }
20160
20161
20162 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20163 PyObject *resultobj = 0;
20164 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20165 bool result;
20166 void *argp1 = 0 ;
20167 int res1 = 0 ;
20168 PyObject *swig_obj[1] ;
20169
20170 if (!args) SWIG_fail;
20171 swig_obj[0] = args;
20172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20173 if (!SWIG_IsOK(res1)) {
20174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20175 }
20176 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20177 {
20178 PyThreadState* __tstate = wxPyBeginAllowThreads();
20179 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20180 wxPyEndAllowThreads(__tstate);
20181 if (PyErr_Occurred()) SWIG_fail;
20182 }
20183 {
20184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20185 }
20186 return resultobj;
20187 fail:
20188 return NULL;
20189 }
20190
20191
20192 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20193 PyObject *resultobj = 0;
20194 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20195 bool result;
20196 void *argp1 = 0 ;
20197 int res1 = 0 ;
20198 PyObject *swig_obj[1] ;
20199
20200 if (!args) SWIG_fail;
20201 swig_obj[0] = args;
20202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20203 if (!SWIG_IsOK(res1)) {
20204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20205 }
20206 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20207 {
20208 PyThreadState* __tstate = wxPyBeginAllowThreads();
20209 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20210 wxPyEndAllowThreads(__tstate);
20211 if (PyErr_Occurred()) SWIG_fail;
20212 }
20213 {
20214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20215 }
20216 return resultobj;
20217 fail:
20218 return NULL;
20219 }
20220
20221
20222 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20223 PyObject *resultobj = 0;
20224 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20225 bool result;
20226 void *argp1 = 0 ;
20227 int res1 = 0 ;
20228 PyObject *swig_obj[1] ;
20229
20230 if (!args) SWIG_fail;
20231 swig_obj[0] = args;
20232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20233 if (!SWIG_IsOK(res1)) {
20234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20235 }
20236 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20237 {
20238 PyThreadState* __tstate = wxPyBeginAllowThreads();
20239 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20240 wxPyEndAllowThreads(__tstate);
20241 if (PyErr_Occurred()) SWIG_fail;
20242 }
20243 {
20244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20245 }
20246 return resultobj;
20247 fail:
20248 return NULL;
20249 }
20250
20251
20252 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20253 PyObject *resultobj = 0;
20254 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20255 bool result;
20256 void *argp1 = 0 ;
20257 int res1 = 0 ;
20258 PyObject *swig_obj[1] ;
20259
20260 if (!args) SWIG_fail;
20261 swig_obj[0] = args;
20262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20263 if (!SWIG_IsOK(res1)) {
20264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20265 }
20266 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20267 {
20268 PyThreadState* __tstate = wxPyBeginAllowThreads();
20269 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20270 wxPyEndAllowThreads(__tstate);
20271 if (PyErr_Occurred()) SWIG_fail;
20272 }
20273 {
20274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20275 }
20276 return resultobj;
20277 fail:
20278 return NULL;
20279 }
20280
20281
20282 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20283 PyObject *resultobj = 0;
20284 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20285 bool result;
20286 void *argp1 = 0 ;
20287 int res1 = 0 ;
20288 PyObject *swig_obj[1] ;
20289
20290 if (!args) SWIG_fail;
20291 swig_obj[0] = args;
20292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20293 if (!SWIG_IsOK(res1)) {
20294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20295 }
20296 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20297 {
20298 PyThreadState* __tstate = wxPyBeginAllowThreads();
20299 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20300 wxPyEndAllowThreads(__tstate);
20301 if (PyErr_Occurred()) SWIG_fail;
20302 }
20303 {
20304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20305 }
20306 return resultobj;
20307 fail:
20308 return NULL;
20309 }
20310
20311
20312 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20313 PyObject *resultobj = 0;
20314 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20315 bool result;
20316 void *argp1 = 0 ;
20317 int res1 = 0 ;
20318 PyObject *swig_obj[1] ;
20319
20320 if (!args) SWIG_fail;
20321 swig_obj[0] = args;
20322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20323 if (!SWIG_IsOK(res1)) {
20324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20325 }
20326 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20327 {
20328 PyThreadState* __tstate = wxPyBeginAllowThreads();
20329 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20330 wxPyEndAllowThreads(__tstate);
20331 if (PyErr_Occurred()) SWIG_fail;
20332 }
20333 {
20334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20335 }
20336 return resultobj;
20337 fail:
20338 return NULL;
20339 }
20340
20341
20342 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20343 PyObject *resultobj = 0;
20344 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20345 bool result;
20346 void *argp1 = 0 ;
20347 int res1 = 0 ;
20348 PyObject *swig_obj[1] ;
20349
20350 if (!args) SWIG_fail;
20351 swig_obj[0] = args;
20352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20353 if (!SWIG_IsOK(res1)) {
20354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20355 }
20356 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20357 {
20358 PyThreadState* __tstate = wxPyBeginAllowThreads();
20359 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20360 wxPyEndAllowThreads(__tstate);
20361 if (PyErr_Occurred()) SWIG_fail;
20362 }
20363 {
20364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20365 }
20366 return resultobj;
20367 fail:
20368 return NULL;
20369 }
20370
20371
20372 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20373 PyObject *resultobj = 0;
20374 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20375 bool result;
20376 void *argp1 = 0 ;
20377 int res1 = 0 ;
20378 PyObject *swig_obj[1] ;
20379
20380 if (!args) SWIG_fail;
20381 swig_obj[0] = args;
20382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20383 if (!SWIG_IsOK(res1)) {
20384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20385 }
20386 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20387 {
20388 PyThreadState* __tstate = wxPyBeginAllowThreads();
20389 result = (bool)(arg1)->LeftIsDown();
20390 wxPyEndAllowThreads(__tstate);
20391 if (PyErr_Occurred()) SWIG_fail;
20392 }
20393 {
20394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20395 }
20396 return resultobj;
20397 fail:
20398 return NULL;
20399 }
20400
20401
20402 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20403 PyObject *resultobj = 0;
20404 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20405 bool result;
20406 void *argp1 = 0 ;
20407 int res1 = 0 ;
20408 PyObject *swig_obj[1] ;
20409
20410 if (!args) SWIG_fail;
20411 swig_obj[0] = args;
20412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20413 if (!SWIG_IsOK(res1)) {
20414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20415 }
20416 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20417 {
20418 PyThreadState* __tstate = wxPyBeginAllowThreads();
20419 result = (bool)(arg1)->MiddleIsDown();
20420 wxPyEndAllowThreads(__tstate);
20421 if (PyErr_Occurred()) SWIG_fail;
20422 }
20423 {
20424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20425 }
20426 return resultobj;
20427 fail:
20428 return NULL;
20429 }
20430
20431
20432 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20433 PyObject *resultobj = 0;
20434 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20435 bool result;
20436 void *argp1 = 0 ;
20437 int res1 = 0 ;
20438 PyObject *swig_obj[1] ;
20439
20440 if (!args) SWIG_fail;
20441 swig_obj[0] = args;
20442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20443 if (!SWIG_IsOK(res1)) {
20444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20445 }
20446 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20447 {
20448 PyThreadState* __tstate = wxPyBeginAllowThreads();
20449 result = (bool)(arg1)->RightIsDown();
20450 wxPyEndAllowThreads(__tstate);
20451 if (PyErr_Occurred()) SWIG_fail;
20452 }
20453 {
20454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20455 }
20456 return resultobj;
20457 fail:
20458 return NULL;
20459 }
20460
20461
20462 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20463 PyObject *resultobj = 0;
20464 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20465 bool result;
20466 void *argp1 = 0 ;
20467 int res1 = 0 ;
20468 PyObject *swig_obj[1] ;
20469
20470 if (!args) SWIG_fail;
20471 swig_obj[0] = args;
20472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20473 if (!SWIG_IsOK(res1)) {
20474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20475 }
20476 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20477 {
20478 PyThreadState* __tstate = wxPyBeginAllowThreads();
20479 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20480 wxPyEndAllowThreads(__tstate);
20481 if (PyErr_Occurred()) SWIG_fail;
20482 }
20483 {
20484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20485 }
20486 return resultobj;
20487 fail:
20488 return NULL;
20489 }
20490
20491
20492 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20493 PyObject *resultobj = 0;
20494 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20495 bool result;
20496 void *argp1 = 0 ;
20497 int res1 = 0 ;
20498 PyObject *swig_obj[1] ;
20499
20500 if (!args) SWIG_fail;
20501 swig_obj[0] = args;
20502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20503 if (!SWIG_IsOK(res1)) {
20504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20505 }
20506 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20507 {
20508 PyThreadState* __tstate = wxPyBeginAllowThreads();
20509 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20510 wxPyEndAllowThreads(__tstate);
20511 if (PyErr_Occurred()) SWIG_fail;
20512 }
20513 {
20514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20515 }
20516 return resultobj;
20517 fail:
20518 return NULL;
20519 }
20520
20521
20522 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20523 PyObject *resultobj = 0;
20524 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20525 bool result;
20526 void *argp1 = 0 ;
20527 int res1 = 0 ;
20528 PyObject *swig_obj[1] ;
20529
20530 if (!args) SWIG_fail;
20531 swig_obj[0] = args;
20532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20533 if (!SWIG_IsOK(res1)) {
20534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20535 }
20536 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20537 {
20538 PyThreadState* __tstate = wxPyBeginAllowThreads();
20539 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20540 wxPyEndAllowThreads(__tstate);
20541 if (PyErr_Occurred()) SWIG_fail;
20542 }
20543 {
20544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20545 }
20546 return resultobj;
20547 fail:
20548 return NULL;
20549 }
20550
20551
20552 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20553 PyObject *resultobj = 0;
20554 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20555 bool result;
20556 void *argp1 = 0 ;
20557 int res1 = 0 ;
20558 PyObject *swig_obj[1] ;
20559
20560 if (!args) SWIG_fail;
20561 swig_obj[0] = args;
20562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20563 if (!SWIG_IsOK(res1)) {
20564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20565 }
20566 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20567 {
20568 PyThreadState* __tstate = wxPyBeginAllowThreads();
20569 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20570 wxPyEndAllowThreads(__tstate);
20571 if (PyErr_Occurred()) SWIG_fail;
20572 }
20573 {
20574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20575 }
20576 return resultobj;
20577 fail:
20578 return NULL;
20579 }
20580
20581
20582 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20583 PyObject *resultobj = 0;
20584 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20585 wxPoint result;
20586 void *argp1 = 0 ;
20587 int res1 = 0 ;
20588 PyObject *swig_obj[1] ;
20589
20590 if (!args) SWIG_fail;
20591 swig_obj[0] = args;
20592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20593 if (!SWIG_IsOK(res1)) {
20594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20595 }
20596 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20597 {
20598 PyThreadState* __tstate = wxPyBeginAllowThreads();
20599 result = (arg1)->GetPosition();
20600 wxPyEndAllowThreads(__tstate);
20601 if (PyErr_Occurred()) SWIG_fail;
20602 }
20603 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20604 return resultobj;
20605 fail:
20606 return NULL;
20607 }
20608
20609
20610 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20611 PyObject *resultobj = 0;
20612 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20613 long *arg2 = (long *) 0 ;
20614 long *arg3 = (long *) 0 ;
20615 void *argp1 = 0 ;
20616 int res1 = 0 ;
20617 long temp2 ;
20618 int res2 = SWIG_TMPOBJ ;
20619 long temp3 ;
20620 int res3 = SWIG_TMPOBJ ;
20621 PyObject *swig_obj[1] ;
20622
20623 arg2 = &temp2;
20624 arg3 = &temp3;
20625 if (!args) SWIG_fail;
20626 swig_obj[0] = args;
20627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20628 if (!SWIG_IsOK(res1)) {
20629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20630 }
20631 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20632 {
20633 PyThreadState* __tstate = wxPyBeginAllowThreads();
20634 (arg1)->GetPosition(arg2,arg3);
20635 wxPyEndAllowThreads(__tstate);
20636 if (PyErr_Occurred()) SWIG_fail;
20637 }
20638 resultobj = SWIG_Py_Void();
20639 if (SWIG_IsTmpObj(res2)) {
20640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20641 } else {
20642 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20644 }
20645 if (SWIG_IsTmpObj(res3)) {
20646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20647 } else {
20648 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20650 }
20651 return resultobj;
20652 fail:
20653 return NULL;
20654 }
20655
20656
20657 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20658 PyObject *resultobj = 0;
20659 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20660 wxDC *arg2 = 0 ;
20661 wxPoint result;
20662 void *argp1 = 0 ;
20663 int res1 = 0 ;
20664 void *argp2 = 0 ;
20665 int res2 = 0 ;
20666 PyObject * obj0 = 0 ;
20667 PyObject * obj1 = 0 ;
20668 char * kwnames[] = {
20669 (char *) "self",(char *) "dc", NULL
20670 };
20671
20672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20674 if (!SWIG_IsOK(res1)) {
20675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20676 }
20677 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20678 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20679 if (!SWIG_IsOK(res2)) {
20680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20681 }
20682 if (!argp2) {
20683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20684 }
20685 arg2 = reinterpret_cast< wxDC * >(argp2);
20686 {
20687 PyThreadState* __tstate = wxPyBeginAllowThreads();
20688 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20689 wxPyEndAllowThreads(__tstate);
20690 if (PyErr_Occurred()) SWIG_fail;
20691 }
20692 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20693 return resultobj;
20694 fail:
20695 return NULL;
20696 }
20697
20698
20699 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20700 PyObject *resultobj = 0;
20701 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20702 int result;
20703 void *argp1 = 0 ;
20704 int res1 = 0 ;
20705 PyObject *swig_obj[1] ;
20706
20707 if (!args) SWIG_fail;
20708 swig_obj[0] = args;
20709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20710 if (!SWIG_IsOK(res1)) {
20711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20712 }
20713 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20714 {
20715 PyThreadState* __tstate = wxPyBeginAllowThreads();
20716 result = (int)((wxMouseEvent const *)arg1)->GetX();
20717 wxPyEndAllowThreads(__tstate);
20718 if (PyErr_Occurred()) SWIG_fail;
20719 }
20720 resultobj = SWIG_From_int(static_cast< int >(result));
20721 return resultobj;
20722 fail:
20723 return NULL;
20724 }
20725
20726
20727 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20728 PyObject *resultobj = 0;
20729 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20730 int result;
20731 void *argp1 = 0 ;
20732 int res1 = 0 ;
20733 PyObject *swig_obj[1] ;
20734
20735 if (!args) SWIG_fail;
20736 swig_obj[0] = args;
20737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20738 if (!SWIG_IsOK(res1)) {
20739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20740 }
20741 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20742 {
20743 PyThreadState* __tstate = wxPyBeginAllowThreads();
20744 result = (int)((wxMouseEvent const *)arg1)->GetY();
20745 wxPyEndAllowThreads(__tstate);
20746 if (PyErr_Occurred()) SWIG_fail;
20747 }
20748 resultobj = SWIG_From_int(static_cast< int >(result));
20749 return resultobj;
20750 fail:
20751 return NULL;
20752 }
20753
20754
20755 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20756 PyObject *resultobj = 0;
20757 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20758 int result;
20759 void *argp1 = 0 ;
20760 int res1 = 0 ;
20761 PyObject *swig_obj[1] ;
20762
20763 if (!args) SWIG_fail;
20764 swig_obj[0] = args;
20765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20766 if (!SWIG_IsOK(res1)) {
20767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20768 }
20769 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20770 {
20771 PyThreadState* __tstate = wxPyBeginAllowThreads();
20772 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20773 wxPyEndAllowThreads(__tstate);
20774 if (PyErr_Occurred()) SWIG_fail;
20775 }
20776 resultobj = SWIG_From_int(static_cast< int >(result));
20777 return resultobj;
20778 fail:
20779 return NULL;
20780 }
20781
20782
20783 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20784 PyObject *resultobj = 0;
20785 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20786 int result;
20787 void *argp1 = 0 ;
20788 int res1 = 0 ;
20789 PyObject *swig_obj[1] ;
20790
20791 if (!args) SWIG_fail;
20792 swig_obj[0] = args;
20793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20794 if (!SWIG_IsOK(res1)) {
20795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20796 }
20797 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20798 {
20799 PyThreadState* __tstate = wxPyBeginAllowThreads();
20800 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20801 wxPyEndAllowThreads(__tstate);
20802 if (PyErr_Occurred()) SWIG_fail;
20803 }
20804 resultobj = SWIG_From_int(static_cast< int >(result));
20805 return resultobj;
20806 fail:
20807 return NULL;
20808 }
20809
20810
20811 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20812 PyObject *resultobj = 0;
20813 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20814 int result;
20815 void *argp1 = 0 ;
20816 int res1 = 0 ;
20817 PyObject *swig_obj[1] ;
20818
20819 if (!args) SWIG_fail;
20820 swig_obj[0] = args;
20821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20822 if (!SWIG_IsOK(res1)) {
20823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20824 }
20825 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20826 {
20827 PyThreadState* __tstate = wxPyBeginAllowThreads();
20828 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20829 wxPyEndAllowThreads(__tstate);
20830 if (PyErr_Occurred()) SWIG_fail;
20831 }
20832 resultobj = SWIG_From_int(static_cast< int >(result));
20833 return resultobj;
20834 fail:
20835 return NULL;
20836 }
20837
20838
20839 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20840 PyObject *resultobj = 0;
20841 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20842 bool result;
20843 void *argp1 = 0 ;
20844 int res1 = 0 ;
20845 PyObject *swig_obj[1] ;
20846
20847 if (!args) SWIG_fail;
20848 swig_obj[0] = args;
20849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20850 if (!SWIG_IsOK(res1)) {
20851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20852 }
20853 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20854 {
20855 PyThreadState* __tstate = wxPyBeginAllowThreads();
20856 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20857 wxPyEndAllowThreads(__tstate);
20858 if (PyErr_Occurred()) SWIG_fail;
20859 }
20860 {
20861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20862 }
20863 return resultobj;
20864 fail:
20865 return NULL;
20866 }
20867
20868
20869 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20870 PyObject *resultobj = 0;
20871 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20872 int arg2 ;
20873 void *argp1 = 0 ;
20874 int res1 = 0 ;
20875 int val2 ;
20876 int ecode2 = 0 ;
20877 PyObject *swig_obj[2] ;
20878
20879 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20881 if (!SWIG_IsOK(res1)) {
20882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20883 }
20884 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20885 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20886 if (!SWIG_IsOK(ecode2)) {
20887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20888 }
20889 arg2 = static_cast< int >(val2);
20890 if (arg1) (arg1)->m_x = arg2;
20891
20892 resultobj = SWIG_Py_Void();
20893 return resultobj;
20894 fail:
20895 return NULL;
20896 }
20897
20898
20899 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20900 PyObject *resultobj = 0;
20901 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20902 int result;
20903 void *argp1 = 0 ;
20904 int res1 = 0 ;
20905 PyObject *swig_obj[1] ;
20906
20907 if (!args) SWIG_fail;
20908 swig_obj[0] = args;
20909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20910 if (!SWIG_IsOK(res1)) {
20911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20912 }
20913 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20914 result = (int) ((arg1)->m_x);
20915 resultobj = SWIG_From_int(static_cast< int >(result));
20916 return resultobj;
20917 fail:
20918 return NULL;
20919 }
20920
20921
20922 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20923 PyObject *resultobj = 0;
20924 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20925 int arg2 ;
20926 void *argp1 = 0 ;
20927 int res1 = 0 ;
20928 int val2 ;
20929 int ecode2 = 0 ;
20930 PyObject *swig_obj[2] ;
20931
20932 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
20933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20934 if (!SWIG_IsOK(res1)) {
20935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20936 }
20937 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20938 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20939 if (!SWIG_IsOK(ecode2)) {
20940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
20941 }
20942 arg2 = static_cast< int >(val2);
20943 if (arg1) (arg1)->m_y = arg2;
20944
20945 resultobj = SWIG_Py_Void();
20946 return resultobj;
20947 fail:
20948 return NULL;
20949 }
20950
20951
20952 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20953 PyObject *resultobj = 0;
20954 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20955 int result;
20956 void *argp1 = 0 ;
20957 int res1 = 0 ;
20958 PyObject *swig_obj[1] ;
20959
20960 if (!args) SWIG_fail;
20961 swig_obj[0] = args;
20962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20963 if (!SWIG_IsOK(res1)) {
20964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20965 }
20966 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20967 result = (int) ((arg1)->m_y);
20968 resultobj = SWIG_From_int(static_cast< int >(result));
20969 return resultobj;
20970 fail:
20971 return NULL;
20972 }
20973
20974
20975 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20976 PyObject *resultobj = 0;
20977 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20978 bool arg2 ;
20979 void *argp1 = 0 ;
20980 int res1 = 0 ;
20981 bool val2 ;
20982 int ecode2 = 0 ;
20983 PyObject *swig_obj[2] ;
20984
20985 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
20986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20987 if (!SWIG_IsOK(res1)) {
20988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20989 }
20990 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20991 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
20992 if (!SWIG_IsOK(ecode2)) {
20993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
20994 }
20995 arg2 = static_cast< bool >(val2);
20996 if (arg1) (arg1)->m_leftDown = arg2;
20997
20998 resultobj = SWIG_Py_Void();
20999 return resultobj;
21000 fail:
21001 return NULL;
21002 }
21003
21004
21005 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21006 PyObject *resultobj = 0;
21007 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21008 bool result;
21009 void *argp1 = 0 ;
21010 int res1 = 0 ;
21011 PyObject *swig_obj[1] ;
21012
21013 if (!args) SWIG_fail;
21014 swig_obj[0] = args;
21015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21016 if (!SWIG_IsOK(res1)) {
21017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21018 }
21019 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21020 result = (bool) ((arg1)->m_leftDown);
21021 {
21022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21023 }
21024 return resultobj;
21025 fail:
21026 return NULL;
21027 }
21028
21029
21030 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21031 PyObject *resultobj = 0;
21032 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21033 bool arg2 ;
21034 void *argp1 = 0 ;
21035 int res1 = 0 ;
21036 bool val2 ;
21037 int ecode2 = 0 ;
21038 PyObject *swig_obj[2] ;
21039
21040 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21042 if (!SWIG_IsOK(res1)) {
21043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21044 }
21045 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21046 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21047 if (!SWIG_IsOK(ecode2)) {
21048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21049 }
21050 arg2 = static_cast< bool >(val2);
21051 if (arg1) (arg1)->m_middleDown = arg2;
21052
21053 resultobj = SWIG_Py_Void();
21054 return resultobj;
21055 fail:
21056 return NULL;
21057 }
21058
21059
21060 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21061 PyObject *resultobj = 0;
21062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21063 bool result;
21064 void *argp1 = 0 ;
21065 int res1 = 0 ;
21066 PyObject *swig_obj[1] ;
21067
21068 if (!args) SWIG_fail;
21069 swig_obj[0] = args;
21070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21071 if (!SWIG_IsOK(res1)) {
21072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21073 }
21074 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21075 result = (bool) ((arg1)->m_middleDown);
21076 {
21077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21078 }
21079 return resultobj;
21080 fail:
21081 return NULL;
21082 }
21083
21084
21085 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21086 PyObject *resultobj = 0;
21087 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21088 bool arg2 ;
21089 void *argp1 = 0 ;
21090 int res1 = 0 ;
21091 bool val2 ;
21092 int ecode2 = 0 ;
21093 PyObject *swig_obj[2] ;
21094
21095 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21097 if (!SWIG_IsOK(res1)) {
21098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21099 }
21100 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21101 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21102 if (!SWIG_IsOK(ecode2)) {
21103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21104 }
21105 arg2 = static_cast< bool >(val2);
21106 if (arg1) (arg1)->m_rightDown = arg2;
21107
21108 resultobj = SWIG_Py_Void();
21109 return resultobj;
21110 fail:
21111 return NULL;
21112 }
21113
21114
21115 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21116 PyObject *resultobj = 0;
21117 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21118 bool result;
21119 void *argp1 = 0 ;
21120 int res1 = 0 ;
21121 PyObject *swig_obj[1] ;
21122
21123 if (!args) SWIG_fail;
21124 swig_obj[0] = args;
21125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21126 if (!SWIG_IsOK(res1)) {
21127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21128 }
21129 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21130 result = (bool) ((arg1)->m_rightDown);
21131 {
21132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21133 }
21134 return resultobj;
21135 fail:
21136 return NULL;
21137 }
21138
21139
21140 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21141 PyObject *resultobj = 0;
21142 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21143 bool arg2 ;
21144 void *argp1 = 0 ;
21145 int res1 = 0 ;
21146 bool val2 ;
21147 int ecode2 = 0 ;
21148 PyObject *swig_obj[2] ;
21149
21150 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21152 if (!SWIG_IsOK(res1)) {
21153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21154 }
21155 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21156 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21157 if (!SWIG_IsOK(ecode2)) {
21158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21159 }
21160 arg2 = static_cast< bool >(val2);
21161 if (arg1) (arg1)->m_controlDown = arg2;
21162
21163 resultobj = SWIG_Py_Void();
21164 return resultobj;
21165 fail:
21166 return NULL;
21167 }
21168
21169
21170 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21171 PyObject *resultobj = 0;
21172 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21173 bool result;
21174 void *argp1 = 0 ;
21175 int res1 = 0 ;
21176 PyObject *swig_obj[1] ;
21177
21178 if (!args) SWIG_fail;
21179 swig_obj[0] = args;
21180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21181 if (!SWIG_IsOK(res1)) {
21182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21183 }
21184 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21185 result = (bool) ((arg1)->m_controlDown);
21186 {
21187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21188 }
21189 return resultobj;
21190 fail:
21191 return NULL;
21192 }
21193
21194
21195 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21196 PyObject *resultobj = 0;
21197 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21198 bool arg2 ;
21199 void *argp1 = 0 ;
21200 int res1 = 0 ;
21201 bool val2 ;
21202 int ecode2 = 0 ;
21203 PyObject *swig_obj[2] ;
21204
21205 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21207 if (!SWIG_IsOK(res1)) {
21208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21209 }
21210 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21211 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21212 if (!SWIG_IsOK(ecode2)) {
21213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21214 }
21215 arg2 = static_cast< bool >(val2);
21216 if (arg1) (arg1)->m_shiftDown = arg2;
21217
21218 resultobj = SWIG_Py_Void();
21219 return resultobj;
21220 fail:
21221 return NULL;
21222 }
21223
21224
21225 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21226 PyObject *resultobj = 0;
21227 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21228 bool result;
21229 void *argp1 = 0 ;
21230 int res1 = 0 ;
21231 PyObject *swig_obj[1] ;
21232
21233 if (!args) SWIG_fail;
21234 swig_obj[0] = args;
21235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21236 if (!SWIG_IsOK(res1)) {
21237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21238 }
21239 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21240 result = (bool) ((arg1)->m_shiftDown);
21241 {
21242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21243 }
21244 return resultobj;
21245 fail:
21246 return NULL;
21247 }
21248
21249
21250 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21251 PyObject *resultobj = 0;
21252 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21253 bool arg2 ;
21254 void *argp1 = 0 ;
21255 int res1 = 0 ;
21256 bool val2 ;
21257 int ecode2 = 0 ;
21258 PyObject *swig_obj[2] ;
21259
21260 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21262 if (!SWIG_IsOK(res1)) {
21263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21264 }
21265 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21266 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21267 if (!SWIG_IsOK(ecode2)) {
21268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21269 }
21270 arg2 = static_cast< bool >(val2);
21271 if (arg1) (arg1)->m_altDown = arg2;
21272
21273 resultobj = SWIG_Py_Void();
21274 return resultobj;
21275 fail:
21276 return NULL;
21277 }
21278
21279
21280 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21281 PyObject *resultobj = 0;
21282 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21283 bool result;
21284 void *argp1 = 0 ;
21285 int res1 = 0 ;
21286 PyObject *swig_obj[1] ;
21287
21288 if (!args) SWIG_fail;
21289 swig_obj[0] = args;
21290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21291 if (!SWIG_IsOK(res1)) {
21292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21293 }
21294 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21295 result = (bool) ((arg1)->m_altDown);
21296 {
21297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21298 }
21299 return resultobj;
21300 fail:
21301 return NULL;
21302 }
21303
21304
21305 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21306 PyObject *resultobj = 0;
21307 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21308 bool arg2 ;
21309 void *argp1 = 0 ;
21310 int res1 = 0 ;
21311 bool val2 ;
21312 int ecode2 = 0 ;
21313 PyObject *swig_obj[2] ;
21314
21315 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21317 if (!SWIG_IsOK(res1)) {
21318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21319 }
21320 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21321 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21322 if (!SWIG_IsOK(ecode2)) {
21323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21324 }
21325 arg2 = static_cast< bool >(val2);
21326 if (arg1) (arg1)->m_metaDown = arg2;
21327
21328 resultobj = SWIG_Py_Void();
21329 return resultobj;
21330 fail:
21331 return NULL;
21332 }
21333
21334
21335 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21336 PyObject *resultobj = 0;
21337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21338 bool result;
21339 void *argp1 = 0 ;
21340 int res1 = 0 ;
21341 PyObject *swig_obj[1] ;
21342
21343 if (!args) SWIG_fail;
21344 swig_obj[0] = args;
21345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21346 if (!SWIG_IsOK(res1)) {
21347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21348 }
21349 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21350 result = (bool) ((arg1)->m_metaDown);
21351 {
21352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21353 }
21354 return resultobj;
21355 fail:
21356 return NULL;
21357 }
21358
21359
21360 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21361 PyObject *resultobj = 0;
21362 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21363 int arg2 ;
21364 void *argp1 = 0 ;
21365 int res1 = 0 ;
21366 int val2 ;
21367 int ecode2 = 0 ;
21368 PyObject *swig_obj[2] ;
21369
21370 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21372 if (!SWIG_IsOK(res1)) {
21373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21374 }
21375 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21376 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21377 if (!SWIG_IsOK(ecode2)) {
21378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21379 }
21380 arg2 = static_cast< int >(val2);
21381 if (arg1) (arg1)->m_wheelRotation = arg2;
21382
21383 resultobj = SWIG_Py_Void();
21384 return resultobj;
21385 fail:
21386 return NULL;
21387 }
21388
21389
21390 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21391 PyObject *resultobj = 0;
21392 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21393 int result;
21394 void *argp1 = 0 ;
21395 int res1 = 0 ;
21396 PyObject *swig_obj[1] ;
21397
21398 if (!args) SWIG_fail;
21399 swig_obj[0] = args;
21400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21401 if (!SWIG_IsOK(res1)) {
21402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21403 }
21404 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21405 result = (int) ((arg1)->m_wheelRotation);
21406 resultobj = SWIG_From_int(static_cast< int >(result));
21407 return resultobj;
21408 fail:
21409 return NULL;
21410 }
21411
21412
21413 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21414 PyObject *resultobj = 0;
21415 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21416 int arg2 ;
21417 void *argp1 = 0 ;
21418 int res1 = 0 ;
21419 int val2 ;
21420 int ecode2 = 0 ;
21421 PyObject *swig_obj[2] ;
21422
21423 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21425 if (!SWIG_IsOK(res1)) {
21426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21427 }
21428 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21429 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21430 if (!SWIG_IsOK(ecode2)) {
21431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21432 }
21433 arg2 = static_cast< int >(val2);
21434 if (arg1) (arg1)->m_wheelDelta = arg2;
21435
21436 resultobj = SWIG_Py_Void();
21437 return resultobj;
21438 fail:
21439 return NULL;
21440 }
21441
21442
21443 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21444 PyObject *resultobj = 0;
21445 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21446 int result;
21447 void *argp1 = 0 ;
21448 int res1 = 0 ;
21449 PyObject *swig_obj[1] ;
21450
21451 if (!args) SWIG_fail;
21452 swig_obj[0] = args;
21453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21454 if (!SWIG_IsOK(res1)) {
21455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21456 }
21457 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21458 result = (int) ((arg1)->m_wheelDelta);
21459 resultobj = SWIG_From_int(static_cast< int >(result));
21460 return resultobj;
21461 fail:
21462 return NULL;
21463 }
21464
21465
21466 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21467 PyObject *resultobj = 0;
21468 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21469 int arg2 ;
21470 void *argp1 = 0 ;
21471 int res1 = 0 ;
21472 int val2 ;
21473 int ecode2 = 0 ;
21474 PyObject *swig_obj[2] ;
21475
21476 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21478 if (!SWIG_IsOK(res1)) {
21479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21480 }
21481 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21482 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21483 if (!SWIG_IsOK(ecode2)) {
21484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21485 }
21486 arg2 = static_cast< int >(val2);
21487 if (arg1) (arg1)->m_linesPerAction = arg2;
21488
21489 resultobj = SWIG_Py_Void();
21490 return resultobj;
21491 fail:
21492 return NULL;
21493 }
21494
21495
21496 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21497 PyObject *resultobj = 0;
21498 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21499 int result;
21500 void *argp1 = 0 ;
21501 int res1 = 0 ;
21502 PyObject *swig_obj[1] ;
21503
21504 if (!args) SWIG_fail;
21505 swig_obj[0] = args;
21506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21507 if (!SWIG_IsOK(res1)) {
21508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21509 }
21510 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21511 result = (int) ((arg1)->m_linesPerAction);
21512 resultobj = SWIG_From_int(static_cast< int >(result));
21513 return resultobj;
21514 fail:
21515 return NULL;
21516 }
21517
21518
21519 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21520 PyObject *obj;
21521 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21522 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21523 return SWIG_Py_Void();
21524 }
21525
21526 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21527 return SWIG_Python_InitShadowInstance(args);
21528 }
21529
21530 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21531 PyObject *resultobj = 0;
21532 int arg1 = (int) 0 ;
21533 int arg2 = (int) 0 ;
21534 wxSetCursorEvent *result = 0 ;
21535 int val1 ;
21536 int ecode1 = 0 ;
21537 int val2 ;
21538 int ecode2 = 0 ;
21539 PyObject * obj0 = 0 ;
21540 PyObject * obj1 = 0 ;
21541 char * kwnames[] = {
21542 (char *) "x",(char *) "y", NULL
21543 };
21544
21545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21546 if (obj0) {
21547 ecode1 = SWIG_AsVal_int(obj0, &val1);
21548 if (!SWIG_IsOK(ecode1)) {
21549 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21550 }
21551 arg1 = static_cast< int >(val1);
21552 }
21553 if (obj1) {
21554 ecode2 = SWIG_AsVal_int(obj1, &val2);
21555 if (!SWIG_IsOK(ecode2)) {
21556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21557 }
21558 arg2 = static_cast< int >(val2);
21559 }
21560 {
21561 PyThreadState* __tstate = wxPyBeginAllowThreads();
21562 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21563 wxPyEndAllowThreads(__tstate);
21564 if (PyErr_Occurred()) SWIG_fail;
21565 }
21566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21567 return resultobj;
21568 fail:
21569 return NULL;
21570 }
21571
21572
21573 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21574 PyObject *resultobj = 0;
21575 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21576 int result;
21577 void *argp1 = 0 ;
21578 int res1 = 0 ;
21579 PyObject *swig_obj[1] ;
21580
21581 if (!args) SWIG_fail;
21582 swig_obj[0] = args;
21583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21584 if (!SWIG_IsOK(res1)) {
21585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21586 }
21587 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21588 {
21589 PyThreadState* __tstate = wxPyBeginAllowThreads();
21590 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21591 wxPyEndAllowThreads(__tstate);
21592 if (PyErr_Occurred()) SWIG_fail;
21593 }
21594 resultobj = SWIG_From_int(static_cast< int >(result));
21595 return resultobj;
21596 fail:
21597 return NULL;
21598 }
21599
21600
21601 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21602 PyObject *resultobj = 0;
21603 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21604 int result;
21605 void *argp1 = 0 ;
21606 int res1 = 0 ;
21607 PyObject *swig_obj[1] ;
21608
21609 if (!args) SWIG_fail;
21610 swig_obj[0] = args;
21611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21612 if (!SWIG_IsOK(res1)) {
21613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21614 }
21615 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21616 {
21617 PyThreadState* __tstate = wxPyBeginAllowThreads();
21618 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21619 wxPyEndAllowThreads(__tstate);
21620 if (PyErr_Occurred()) SWIG_fail;
21621 }
21622 resultobj = SWIG_From_int(static_cast< int >(result));
21623 return resultobj;
21624 fail:
21625 return NULL;
21626 }
21627
21628
21629 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21630 PyObject *resultobj = 0;
21631 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21632 wxCursor *arg2 = 0 ;
21633 void *argp1 = 0 ;
21634 int res1 = 0 ;
21635 void *argp2 = 0 ;
21636 int res2 = 0 ;
21637 PyObject * obj0 = 0 ;
21638 PyObject * obj1 = 0 ;
21639 char * kwnames[] = {
21640 (char *) "self",(char *) "cursor", NULL
21641 };
21642
21643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21645 if (!SWIG_IsOK(res1)) {
21646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21647 }
21648 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21649 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21650 if (!SWIG_IsOK(res2)) {
21651 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21652 }
21653 if (!argp2) {
21654 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21655 }
21656 arg2 = reinterpret_cast< wxCursor * >(argp2);
21657 {
21658 PyThreadState* __tstate = wxPyBeginAllowThreads();
21659 (arg1)->SetCursor((wxCursor const &)*arg2);
21660 wxPyEndAllowThreads(__tstate);
21661 if (PyErr_Occurred()) SWIG_fail;
21662 }
21663 resultobj = SWIG_Py_Void();
21664 return resultobj;
21665 fail:
21666 return NULL;
21667 }
21668
21669
21670 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21671 PyObject *resultobj = 0;
21672 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21673 wxCursor *result = 0 ;
21674 void *argp1 = 0 ;
21675 int res1 = 0 ;
21676 PyObject *swig_obj[1] ;
21677
21678 if (!args) SWIG_fail;
21679 swig_obj[0] = args;
21680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21681 if (!SWIG_IsOK(res1)) {
21682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21683 }
21684 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21685 {
21686 PyThreadState* __tstate = wxPyBeginAllowThreads();
21687 {
21688 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21689 result = (wxCursor *) &_result_ref;
21690 }
21691 wxPyEndAllowThreads(__tstate);
21692 if (PyErr_Occurred()) SWIG_fail;
21693 }
21694 {
21695 wxCursor* resultptr = new wxCursor(*result);
21696 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21697 }
21698 return resultobj;
21699 fail:
21700 return NULL;
21701 }
21702
21703
21704 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21705 PyObject *resultobj = 0;
21706 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21707 bool result;
21708 void *argp1 = 0 ;
21709 int res1 = 0 ;
21710 PyObject *swig_obj[1] ;
21711
21712 if (!args) SWIG_fail;
21713 swig_obj[0] = args;
21714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21715 if (!SWIG_IsOK(res1)) {
21716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21717 }
21718 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21719 {
21720 PyThreadState* __tstate = wxPyBeginAllowThreads();
21721 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21722 wxPyEndAllowThreads(__tstate);
21723 if (PyErr_Occurred()) SWIG_fail;
21724 }
21725 {
21726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21727 }
21728 return resultobj;
21729 fail:
21730 return NULL;
21731 }
21732
21733
21734 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21735 PyObject *obj;
21736 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21737 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21738 return SWIG_Py_Void();
21739 }
21740
21741 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21742 return SWIG_Python_InitShadowInstance(args);
21743 }
21744
21745 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21746 PyObject *resultobj = 0;
21747 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21748 wxKeyEvent *result = 0 ;
21749 int val1 ;
21750 int ecode1 = 0 ;
21751 PyObject * obj0 = 0 ;
21752 char * kwnames[] = {
21753 (char *) "eventType", NULL
21754 };
21755
21756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21757 if (obj0) {
21758 ecode1 = SWIG_AsVal_int(obj0, &val1);
21759 if (!SWIG_IsOK(ecode1)) {
21760 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21761 }
21762 arg1 = static_cast< wxEventType >(val1);
21763 }
21764 {
21765 PyThreadState* __tstate = wxPyBeginAllowThreads();
21766 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21767 wxPyEndAllowThreads(__tstate);
21768 if (PyErr_Occurred()) SWIG_fail;
21769 }
21770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21771 return resultobj;
21772 fail:
21773 return NULL;
21774 }
21775
21776
21777 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21778 PyObject *resultobj = 0;
21779 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21780 int result;
21781 void *argp1 = 0 ;
21782 int res1 = 0 ;
21783 PyObject *swig_obj[1] ;
21784
21785 if (!args) SWIG_fail;
21786 swig_obj[0] = args;
21787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21788 if (!SWIG_IsOK(res1)) {
21789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21790 }
21791 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21792 {
21793 PyThreadState* __tstate = wxPyBeginAllowThreads();
21794 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21795 wxPyEndAllowThreads(__tstate);
21796 if (PyErr_Occurred()) SWIG_fail;
21797 }
21798 resultobj = SWIG_From_int(static_cast< int >(result));
21799 return resultobj;
21800 fail:
21801 return NULL;
21802 }
21803
21804
21805 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21806 PyObject *resultobj = 0;
21807 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21808 bool result;
21809 void *argp1 = 0 ;
21810 int res1 = 0 ;
21811 PyObject *swig_obj[1] ;
21812
21813 if (!args) SWIG_fail;
21814 swig_obj[0] = args;
21815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21816 if (!SWIG_IsOK(res1)) {
21817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21818 }
21819 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21820 {
21821 PyThreadState* __tstate = wxPyBeginAllowThreads();
21822 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21823 wxPyEndAllowThreads(__tstate);
21824 if (PyErr_Occurred()) SWIG_fail;
21825 }
21826 {
21827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21828 }
21829 return resultobj;
21830 fail:
21831 return NULL;
21832 }
21833
21834
21835 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21836 PyObject *resultobj = 0;
21837 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21838 bool result;
21839 void *argp1 = 0 ;
21840 int res1 = 0 ;
21841 PyObject *swig_obj[1] ;
21842
21843 if (!args) SWIG_fail;
21844 swig_obj[0] = args;
21845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21846 if (!SWIG_IsOK(res1)) {
21847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21848 }
21849 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21850 {
21851 PyThreadState* __tstate = wxPyBeginAllowThreads();
21852 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21853 wxPyEndAllowThreads(__tstate);
21854 if (PyErr_Occurred()) SWIG_fail;
21855 }
21856 {
21857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21858 }
21859 return resultobj;
21860 fail:
21861 return NULL;
21862 }
21863
21864
21865 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21866 PyObject *resultobj = 0;
21867 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21868 bool result;
21869 void *argp1 = 0 ;
21870 int res1 = 0 ;
21871 PyObject *swig_obj[1] ;
21872
21873 if (!args) SWIG_fail;
21874 swig_obj[0] = args;
21875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21876 if (!SWIG_IsOK(res1)) {
21877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21878 }
21879 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21880 {
21881 PyThreadState* __tstate = wxPyBeginAllowThreads();
21882 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21883 wxPyEndAllowThreads(__tstate);
21884 if (PyErr_Occurred()) SWIG_fail;
21885 }
21886 {
21887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21888 }
21889 return resultobj;
21890 fail:
21891 return NULL;
21892 }
21893
21894
21895 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21896 PyObject *resultobj = 0;
21897 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21898 bool result;
21899 void *argp1 = 0 ;
21900 int res1 = 0 ;
21901 PyObject *swig_obj[1] ;
21902
21903 if (!args) SWIG_fail;
21904 swig_obj[0] = args;
21905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21906 if (!SWIG_IsOK(res1)) {
21907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21908 }
21909 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21910 {
21911 PyThreadState* __tstate = wxPyBeginAllowThreads();
21912 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
21913 wxPyEndAllowThreads(__tstate);
21914 if (PyErr_Occurred()) SWIG_fail;
21915 }
21916 {
21917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21918 }
21919 return resultobj;
21920 fail:
21921 return NULL;
21922 }
21923
21924
21925 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21926 PyObject *resultobj = 0;
21927 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21928 bool result;
21929 void *argp1 = 0 ;
21930 int res1 = 0 ;
21931 PyObject *swig_obj[1] ;
21932
21933 if (!args) SWIG_fail;
21934 swig_obj[0] = args;
21935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21936 if (!SWIG_IsOK(res1)) {
21937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21938 }
21939 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21940 {
21941 PyThreadState* __tstate = wxPyBeginAllowThreads();
21942 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
21943 wxPyEndAllowThreads(__tstate);
21944 if (PyErr_Occurred()) SWIG_fail;
21945 }
21946 {
21947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21948 }
21949 return resultobj;
21950 fail:
21951 return NULL;
21952 }
21953
21954
21955 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21956 PyObject *resultobj = 0;
21957 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21958 bool result;
21959 void *argp1 = 0 ;
21960 int res1 = 0 ;
21961 PyObject *swig_obj[1] ;
21962
21963 if (!args) SWIG_fail;
21964 swig_obj[0] = args;
21965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21966 if (!SWIG_IsOK(res1)) {
21967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21968 }
21969 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21970 {
21971 PyThreadState* __tstate = wxPyBeginAllowThreads();
21972 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
21973 wxPyEndAllowThreads(__tstate);
21974 if (PyErr_Occurred()) SWIG_fail;
21975 }
21976 {
21977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21978 }
21979 return resultobj;
21980 fail:
21981 return NULL;
21982 }
21983
21984
21985 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21986 PyObject *resultobj = 0;
21987 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21988 int result;
21989 void *argp1 = 0 ;
21990 int res1 = 0 ;
21991 PyObject *swig_obj[1] ;
21992
21993 if (!args) SWIG_fail;
21994 swig_obj[0] = args;
21995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21996 if (!SWIG_IsOK(res1)) {
21997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21998 }
21999 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22000 {
22001 PyThreadState* __tstate = wxPyBeginAllowThreads();
22002 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22003 wxPyEndAllowThreads(__tstate);
22004 if (PyErr_Occurred()) SWIG_fail;
22005 }
22006 resultobj = SWIG_From_int(static_cast< int >(result));
22007 return resultobj;
22008 fail:
22009 return NULL;
22010 }
22011
22012
22013 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22014 PyObject *resultobj = 0;
22015 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22016 int result;
22017 void *argp1 = 0 ;
22018 int res1 = 0 ;
22019 PyObject *swig_obj[1] ;
22020
22021 if (!args) SWIG_fail;
22022 swig_obj[0] = args;
22023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22024 if (!SWIG_IsOK(res1)) {
22025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22026 }
22027 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22028 {
22029 PyThreadState* __tstate = wxPyBeginAllowThreads();
22030 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22031 wxPyEndAllowThreads(__tstate);
22032 if (PyErr_Occurred()) SWIG_fail;
22033 }
22034 resultobj = SWIG_From_int(static_cast< int >(result));
22035 return resultobj;
22036 fail:
22037 return NULL;
22038 }
22039
22040
22041 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22042 PyObject *resultobj = 0;
22043 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22044 unsigned int result;
22045 void *argp1 = 0 ;
22046 int res1 = 0 ;
22047 PyObject *swig_obj[1] ;
22048
22049 if (!args) SWIG_fail;
22050 swig_obj[0] = args;
22051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22052 if (!SWIG_IsOK(res1)) {
22053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22054 }
22055 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22056 {
22057 PyThreadState* __tstate = wxPyBeginAllowThreads();
22058 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22059 wxPyEndAllowThreads(__tstate);
22060 if (PyErr_Occurred()) SWIG_fail;
22061 }
22062 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22063 return resultobj;
22064 fail:
22065 return NULL;
22066 }
22067
22068
22069 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22070 PyObject *resultobj = 0;
22071 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22072 unsigned int result;
22073 void *argp1 = 0 ;
22074 int res1 = 0 ;
22075 PyObject *swig_obj[1] ;
22076
22077 if (!args) SWIG_fail;
22078 swig_obj[0] = args;
22079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22080 if (!SWIG_IsOK(res1)) {
22081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22082 }
22083 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22084 {
22085 PyThreadState* __tstate = wxPyBeginAllowThreads();
22086 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22087 wxPyEndAllowThreads(__tstate);
22088 if (PyErr_Occurred()) SWIG_fail;
22089 }
22090 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22091 return resultobj;
22092 fail:
22093 return NULL;
22094 }
22095
22096
22097 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22098 PyObject *resultobj = 0;
22099 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22100 wxPoint result;
22101 void *argp1 = 0 ;
22102 int res1 = 0 ;
22103 PyObject *swig_obj[1] ;
22104
22105 if (!args) SWIG_fail;
22106 swig_obj[0] = args;
22107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22108 if (!SWIG_IsOK(res1)) {
22109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22110 }
22111 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22112 {
22113 PyThreadState* __tstate = wxPyBeginAllowThreads();
22114 result = (arg1)->GetPosition();
22115 wxPyEndAllowThreads(__tstate);
22116 if (PyErr_Occurred()) SWIG_fail;
22117 }
22118 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22119 return resultobj;
22120 fail:
22121 return NULL;
22122 }
22123
22124
22125 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22126 PyObject *resultobj = 0;
22127 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22128 long *arg2 = (long *) 0 ;
22129 long *arg3 = (long *) 0 ;
22130 void *argp1 = 0 ;
22131 int res1 = 0 ;
22132 long temp2 ;
22133 int res2 = SWIG_TMPOBJ ;
22134 long temp3 ;
22135 int res3 = SWIG_TMPOBJ ;
22136 PyObject *swig_obj[1] ;
22137
22138 arg2 = &temp2;
22139 arg3 = &temp3;
22140 if (!args) SWIG_fail;
22141 swig_obj[0] = args;
22142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22143 if (!SWIG_IsOK(res1)) {
22144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22145 }
22146 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22147 {
22148 PyThreadState* __tstate = wxPyBeginAllowThreads();
22149 (arg1)->GetPosition(arg2,arg3);
22150 wxPyEndAllowThreads(__tstate);
22151 if (PyErr_Occurred()) SWIG_fail;
22152 }
22153 resultobj = SWIG_Py_Void();
22154 if (SWIG_IsTmpObj(res2)) {
22155 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22156 } else {
22157 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22158 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22159 }
22160 if (SWIG_IsTmpObj(res3)) {
22161 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22162 } else {
22163 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22164 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22165 }
22166 return resultobj;
22167 fail:
22168 return NULL;
22169 }
22170
22171
22172 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22173 PyObject *resultobj = 0;
22174 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22175 int result;
22176 void *argp1 = 0 ;
22177 int res1 = 0 ;
22178 PyObject *swig_obj[1] ;
22179
22180 if (!args) SWIG_fail;
22181 swig_obj[0] = args;
22182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22183 if (!SWIG_IsOK(res1)) {
22184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22185 }
22186 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22187 {
22188 PyThreadState* __tstate = wxPyBeginAllowThreads();
22189 result = (int)((wxKeyEvent const *)arg1)->GetX();
22190 wxPyEndAllowThreads(__tstate);
22191 if (PyErr_Occurred()) SWIG_fail;
22192 }
22193 resultobj = SWIG_From_int(static_cast< int >(result));
22194 return resultobj;
22195 fail:
22196 return NULL;
22197 }
22198
22199
22200 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22201 PyObject *resultobj = 0;
22202 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22203 int result;
22204 void *argp1 = 0 ;
22205 int res1 = 0 ;
22206 PyObject *swig_obj[1] ;
22207
22208 if (!args) SWIG_fail;
22209 swig_obj[0] = args;
22210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22211 if (!SWIG_IsOK(res1)) {
22212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22213 }
22214 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22215 {
22216 PyThreadState* __tstate = wxPyBeginAllowThreads();
22217 result = (int)((wxKeyEvent const *)arg1)->GetY();
22218 wxPyEndAllowThreads(__tstate);
22219 if (PyErr_Occurred()) SWIG_fail;
22220 }
22221 resultobj = SWIG_From_int(static_cast< int >(result));
22222 return resultobj;
22223 fail:
22224 return NULL;
22225 }
22226
22227
22228 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22229 PyObject *resultobj = 0;
22230 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22231 int arg2 ;
22232 void *argp1 = 0 ;
22233 int res1 = 0 ;
22234 int val2 ;
22235 int ecode2 = 0 ;
22236 PyObject *swig_obj[2] ;
22237
22238 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22240 if (!SWIG_IsOK(res1)) {
22241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22242 }
22243 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22244 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22245 if (!SWIG_IsOK(ecode2)) {
22246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22247 }
22248 arg2 = static_cast< int >(val2);
22249 if (arg1) (arg1)->m_x = arg2;
22250
22251 resultobj = SWIG_Py_Void();
22252 return resultobj;
22253 fail:
22254 return NULL;
22255 }
22256
22257
22258 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22259 PyObject *resultobj = 0;
22260 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22261 int result;
22262 void *argp1 = 0 ;
22263 int res1 = 0 ;
22264 PyObject *swig_obj[1] ;
22265
22266 if (!args) SWIG_fail;
22267 swig_obj[0] = args;
22268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22269 if (!SWIG_IsOK(res1)) {
22270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22271 }
22272 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22273 result = (int) ((arg1)->m_x);
22274 resultobj = SWIG_From_int(static_cast< int >(result));
22275 return resultobj;
22276 fail:
22277 return NULL;
22278 }
22279
22280
22281 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22282 PyObject *resultobj = 0;
22283 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22284 int arg2 ;
22285 void *argp1 = 0 ;
22286 int res1 = 0 ;
22287 int val2 ;
22288 int ecode2 = 0 ;
22289 PyObject *swig_obj[2] ;
22290
22291 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22293 if (!SWIG_IsOK(res1)) {
22294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22295 }
22296 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22297 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22298 if (!SWIG_IsOK(ecode2)) {
22299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22300 }
22301 arg2 = static_cast< int >(val2);
22302 if (arg1) (arg1)->m_y = arg2;
22303
22304 resultobj = SWIG_Py_Void();
22305 return resultobj;
22306 fail:
22307 return NULL;
22308 }
22309
22310
22311 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22312 PyObject *resultobj = 0;
22313 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22314 int result;
22315 void *argp1 = 0 ;
22316 int res1 = 0 ;
22317 PyObject *swig_obj[1] ;
22318
22319 if (!args) SWIG_fail;
22320 swig_obj[0] = args;
22321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22322 if (!SWIG_IsOK(res1)) {
22323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22324 }
22325 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22326 result = (int) ((arg1)->m_y);
22327 resultobj = SWIG_From_int(static_cast< int >(result));
22328 return resultobj;
22329 fail:
22330 return NULL;
22331 }
22332
22333
22334 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22335 PyObject *resultobj = 0;
22336 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22337 long arg2 ;
22338 void *argp1 = 0 ;
22339 int res1 = 0 ;
22340 long val2 ;
22341 int ecode2 = 0 ;
22342 PyObject *swig_obj[2] ;
22343
22344 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22346 if (!SWIG_IsOK(res1)) {
22347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22348 }
22349 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22350 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22351 if (!SWIG_IsOK(ecode2)) {
22352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22353 }
22354 arg2 = static_cast< long >(val2);
22355 if (arg1) (arg1)->m_keyCode = arg2;
22356
22357 resultobj = SWIG_Py_Void();
22358 return resultobj;
22359 fail:
22360 return NULL;
22361 }
22362
22363
22364 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22365 PyObject *resultobj = 0;
22366 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22367 long result;
22368 void *argp1 = 0 ;
22369 int res1 = 0 ;
22370 PyObject *swig_obj[1] ;
22371
22372 if (!args) SWIG_fail;
22373 swig_obj[0] = args;
22374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22375 if (!SWIG_IsOK(res1)) {
22376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22377 }
22378 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22379 result = (long) ((arg1)->m_keyCode);
22380 resultobj = SWIG_From_long(static_cast< long >(result));
22381 return resultobj;
22382 fail:
22383 return NULL;
22384 }
22385
22386
22387 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22388 PyObject *resultobj = 0;
22389 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22390 bool arg2 ;
22391 void *argp1 = 0 ;
22392 int res1 = 0 ;
22393 bool val2 ;
22394 int ecode2 = 0 ;
22395 PyObject *swig_obj[2] ;
22396
22397 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22399 if (!SWIG_IsOK(res1)) {
22400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22401 }
22402 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22403 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22404 if (!SWIG_IsOK(ecode2)) {
22405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22406 }
22407 arg2 = static_cast< bool >(val2);
22408 if (arg1) (arg1)->m_controlDown = arg2;
22409
22410 resultobj = SWIG_Py_Void();
22411 return resultobj;
22412 fail:
22413 return NULL;
22414 }
22415
22416
22417 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22418 PyObject *resultobj = 0;
22419 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22420 bool result;
22421 void *argp1 = 0 ;
22422 int res1 = 0 ;
22423 PyObject *swig_obj[1] ;
22424
22425 if (!args) SWIG_fail;
22426 swig_obj[0] = args;
22427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22428 if (!SWIG_IsOK(res1)) {
22429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22430 }
22431 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22432 result = (bool) ((arg1)->m_controlDown);
22433 {
22434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22435 }
22436 return resultobj;
22437 fail:
22438 return NULL;
22439 }
22440
22441
22442 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22443 PyObject *resultobj = 0;
22444 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22445 bool arg2 ;
22446 void *argp1 = 0 ;
22447 int res1 = 0 ;
22448 bool val2 ;
22449 int ecode2 = 0 ;
22450 PyObject *swig_obj[2] ;
22451
22452 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22454 if (!SWIG_IsOK(res1)) {
22455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22456 }
22457 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22458 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22459 if (!SWIG_IsOK(ecode2)) {
22460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22461 }
22462 arg2 = static_cast< bool >(val2);
22463 if (arg1) (arg1)->m_shiftDown = arg2;
22464
22465 resultobj = SWIG_Py_Void();
22466 return resultobj;
22467 fail:
22468 return NULL;
22469 }
22470
22471
22472 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22473 PyObject *resultobj = 0;
22474 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22475 bool result;
22476 void *argp1 = 0 ;
22477 int res1 = 0 ;
22478 PyObject *swig_obj[1] ;
22479
22480 if (!args) SWIG_fail;
22481 swig_obj[0] = args;
22482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22483 if (!SWIG_IsOK(res1)) {
22484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22485 }
22486 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22487 result = (bool) ((arg1)->m_shiftDown);
22488 {
22489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22490 }
22491 return resultobj;
22492 fail:
22493 return NULL;
22494 }
22495
22496
22497 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22498 PyObject *resultobj = 0;
22499 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22500 bool arg2 ;
22501 void *argp1 = 0 ;
22502 int res1 = 0 ;
22503 bool val2 ;
22504 int ecode2 = 0 ;
22505 PyObject *swig_obj[2] ;
22506
22507 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22509 if (!SWIG_IsOK(res1)) {
22510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22511 }
22512 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22513 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22514 if (!SWIG_IsOK(ecode2)) {
22515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22516 }
22517 arg2 = static_cast< bool >(val2);
22518 if (arg1) (arg1)->m_altDown = arg2;
22519
22520 resultobj = SWIG_Py_Void();
22521 return resultobj;
22522 fail:
22523 return NULL;
22524 }
22525
22526
22527 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22528 PyObject *resultobj = 0;
22529 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22530 bool result;
22531 void *argp1 = 0 ;
22532 int res1 = 0 ;
22533 PyObject *swig_obj[1] ;
22534
22535 if (!args) SWIG_fail;
22536 swig_obj[0] = args;
22537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22538 if (!SWIG_IsOK(res1)) {
22539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22540 }
22541 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22542 result = (bool) ((arg1)->m_altDown);
22543 {
22544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22545 }
22546 return resultobj;
22547 fail:
22548 return NULL;
22549 }
22550
22551
22552 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22553 PyObject *resultobj = 0;
22554 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22555 bool arg2 ;
22556 void *argp1 = 0 ;
22557 int res1 = 0 ;
22558 bool val2 ;
22559 int ecode2 = 0 ;
22560 PyObject *swig_obj[2] ;
22561
22562 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22564 if (!SWIG_IsOK(res1)) {
22565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22566 }
22567 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22568 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22569 if (!SWIG_IsOK(ecode2)) {
22570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22571 }
22572 arg2 = static_cast< bool >(val2);
22573 if (arg1) (arg1)->m_metaDown = arg2;
22574
22575 resultobj = SWIG_Py_Void();
22576 return resultobj;
22577 fail:
22578 return NULL;
22579 }
22580
22581
22582 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22583 PyObject *resultobj = 0;
22584 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22585 bool result;
22586 void *argp1 = 0 ;
22587 int res1 = 0 ;
22588 PyObject *swig_obj[1] ;
22589
22590 if (!args) SWIG_fail;
22591 swig_obj[0] = args;
22592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22593 if (!SWIG_IsOK(res1)) {
22594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22595 }
22596 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22597 result = (bool) ((arg1)->m_metaDown);
22598 {
22599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22600 }
22601 return resultobj;
22602 fail:
22603 return NULL;
22604 }
22605
22606
22607 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22608 PyObject *resultobj = 0;
22609 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22610 bool arg2 ;
22611 void *argp1 = 0 ;
22612 int res1 = 0 ;
22613 bool val2 ;
22614 int ecode2 = 0 ;
22615 PyObject *swig_obj[2] ;
22616
22617 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22619 if (!SWIG_IsOK(res1)) {
22620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22621 }
22622 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22623 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22624 if (!SWIG_IsOK(ecode2)) {
22625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22626 }
22627 arg2 = static_cast< bool >(val2);
22628 if (arg1) (arg1)->m_scanCode = arg2;
22629
22630 resultobj = SWIG_Py_Void();
22631 return resultobj;
22632 fail:
22633 return NULL;
22634 }
22635
22636
22637 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22638 PyObject *resultobj = 0;
22639 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22640 bool result;
22641 void *argp1 = 0 ;
22642 int res1 = 0 ;
22643 PyObject *swig_obj[1] ;
22644
22645 if (!args) SWIG_fail;
22646 swig_obj[0] = args;
22647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22648 if (!SWIG_IsOK(res1)) {
22649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22650 }
22651 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22652 result = (bool) ((arg1)->m_scanCode);
22653 {
22654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22655 }
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22663 PyObject *resultobj = 0;
22664 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22665 unsigned int arg2 ;
22666 void *argp1 = 0 ;
22667 int res1 = 0 ;
22668 unsigned int val2 ;
22669 int ecode2 = 0 ;
22670 PyObject *swig_obj[2] ;
22671
22672 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22674 if (!SWIG_IsOK(res1)) {
22675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22676 }
22677 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22678 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22679 if (!SWIG_IsOK(ecode2)) {
22680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22681 }
22682 arg2 = static_cast< unsigned int >(val2);
22683 if (arg1) (arg1)->m_rawCode = arg2;
22684
22685 resultobj = SWIG_Py_Void();
22686 return resultobj;
22687 fail:
22688 return NULL;
22689 }
22690
22691
22692 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22693 PyObject *resultobj = 0;
22694 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22695 unsigned int result;
22696 void *argp1 = 0 ;
22697 int res1 = 0 ;
22698 PyObject *swig_obj[1] ;
22699
22700 if (!args) SWIG_fail;
22701 swig_obj[0] = args;
22702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22703 if (!SWIG_IsOK(res1)) {
22704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22705 }
22706 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22707 result = (unsigned int) ((arg1)->m_rawCode);
22708 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22709 return resultobj;
22710 fail:
22711 return NULL;
22712 }
22713
22714
22715 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22716 PyObject *resultobj = 0;
22717 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22718 unsigned int arg2 ;
22719 void *argp1 = 0 ;
22720 int res1 = 0 ;
22721 unsigned int val2 ;
22722 int ecode2 = 0 ;
22723 PyObject *swig_obj[2] ;
22724
22725 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22727 if (!SWIG_IsOK(res1)) {
22728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22729 }
22730 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22731 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22732 if (!SWIG_IsOK(ecode2)) {
22733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22734 }
22735 arg2 = static_cast< unsigned int >(val2);
22736 if (arg1) (arg1)->m_rawFlags = arg2;
22737
22738 resultobj = SWIG_Py_Void();
22739 return resultobj;
22740 fail:
22741 return NULL;
22742 }
22743
22744
22745 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22746 PyObject *resultobj = 0;
22747 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22748 unsigned int result;
22749 void *argp1 = 0 ;
22750 int res1 = 0 ;
22751 PyObject *swig_obj[1] ;
22752
22753 if (!args) SWIG_fail;
22754 swig_obj[0] = args;
22755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22756 if (!SWIG_IsOK(res1)) {
22757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22758 }
22759 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22760 result = (unsigned int) ((arg1)->m_rawFlags);
22761 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22762 return resultobj;
22763 fail:
22764 return NULL;
22765 }
22766
22767
22768 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22769 PyObject *obj;
22770 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22771 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22772 return SWIG_Py_Void();
22773 }
22774
22775 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22776 return SWIG_Python_InitShadowInstance(args);
22777 }
22778
22779 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22780 PyObject *resultobj = 0;
22781 wxSize const &arg1_defvalue = wxDefaultSize ;
22782 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22783 int arg2 = (int) 0 ;
22784 wxSizeEvent *result = 0 ;
22785 wxSize temp1 ;
22786 int val2 ;
22787 int ecode2 = 0 ;
22788 PyObject * obj0 = 0 ;
22789 PyObject * obj1 = 0 ;
22790 char * kwnames[] = {
22791 (char *) "sz",(char *) "winid", NULL
22792 };
22793
22794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22795 if (obj0) {
22796 {
22797 arg1 = &temp1;
22798 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22799 }
22800 }
22801 if (obj1) {
22802 ecode2 = SWIG_AsVal_int(obj1, &val2);
22803 if (!SWIG_IsOK(ecode2)) {
22804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22805 }
22806 arg2 = static_cast< int >(val2);
22807 }
22808 {
22809 PyThreadState* __tstate = wxPyBeginAllowThreads();
22810 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22811 wxPyEndAllowThreads(__tstate);
22812 if (PyErr_Occurred()) SWIG_fail;
22813 }
22814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22815 return resultobj;
22816 fail:
22817 return NULL;
22818 }
22819
22820
22821 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22822 PyObject *resultobj = 0;
22823 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22824 wxSize result;
22825 void *argp1 = 0 ;
22826 int res1 = 0 ;
22827 PyObject *swig_obj[1] ;
22828
22829 if (!args) SWIG_fail;
22830 swig_obj[0] = args;
22831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22832 if (!SWIG_IsOK(res1)) {
22833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22834 }
22835 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22836 {
22837 PyThreadState* __tstate = wxPyBeginAllowThreads();
22838 result = ((wxSizeEvent const *)arg1)->GetSize();
22839 wxPyEndAllowThreads(__tstate);
22840 if (PyErr_Occurred()) SWIG_fail;
22841 }
22842 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22843 return resultobj;
22844 fail:
22845 return NULL;
22846 }
22847
22848
22849 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22850 PyObject *resultobj = 0;
22851 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22852 wxRect result;
22853 void *argp1 = 0 ;
22854 int res1 = 0 ;
22855 PyObject *swig_obj[1] ;
22856
22857 if (!args) SWIG_fail;
22858 swig_obj[0] = args;
22859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22860 if (!SWIG_IsOK(res1)) {
22861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22862 }
22863 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22864 {
22865 PyThreadState* __tstate = wxPyBeginAllowThreads();
22866 result = ((wxSizeEvent const *)arg1)->GetRect();
22867 wxPyEndAllowThreads(__tstate);
22868 if (PyErr_Occurred()) SWIG_fail;
22869 }
22870 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22871 return resultobj;
22872 fail:
22873 return NULL;
22874 }
22875
22876
22877 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22878 PyObject *resultobj = 0;
22879 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22880 wxRect arg2 ;
22881 void *argp1 = 0 ;
22882 int res1 = 0 ;
22883 void *argp2 ;
22884 int res2 = 0 ;
22885 PyObject * obj0 = 0 ;
22886 PyObject * obj1 = 0 ;
22887 char * kwnames[] = {
22888 (char *) "self",(char *) "rect", NULL
22889 };
22890
22891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
22892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22893 if (!SWIG_IsOK(res1)) {
22894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22895 }
22896 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22897 {
22898 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
22899 if (!SWIG_IsOK(res2)) {
22900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22901 }
22902 if (!argp2) {
22903 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22904 } else {
22905 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
22906 arg2 = *temp;
22907 if (SWIG_IsNewObj(res2)) delete temp;
22908 }
22909 }
22910 {
22911 PyThreadState* __tstate = wxPyBeginAllowThreads();
22912 (arg1)->SetRect(arg2);
22913 wxPyEndAllowThreads(__tstate);
22914 if (PyErr_Occurred()) SWIG_fail;
22915 }
22916 resultobj = SWIG_Py_Void();
22917 return resultobj;
22918 fail:
22919 return NULL;
22920 }
22921
22922
22923 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22924 PyObject *resultobj = 0;
22925 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22926 wxSize arg2 ;
22927 void *argp1 = 0 ;
22928 int res1 = 0 ;
22929 void *argp2 ;
22930 int res2 = 0 ;
22931 PyObject * obj0 = 0 ;
22932 PyObject * obj1 = 0 ;
22933 char * kwnames[] = {
22934 (char *) "self",(char *) "size", NULL
22935 };
22936
22937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
22938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22939 if (!SWIG_IsOK(res1)) {
22940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22941 }
22942 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22943 {
22944 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
22945 if (!SWIG_IsOK(res2)) {
22946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22947 }
22948 if (!argp2) {
22949 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22950 } else {
22951 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
22952 arg2 = *temp;
22953 if (SWIG_IsNewObj(res2)) delete temp;
22954 }
22955 }
22956 {
22957 PyThreadState* __tstate = wxPyBeginAllowThreads();
22958 wxSizeEvent_SetSize(arg1,arg2);
22959 wxPyEndAllowThreads(__tstate);
22960 if (PyErr_Occurred()) SWIG_fail;
22961 }
22962 resultobj = SWIG_Py_Void();
22963 return resultobj;
22964 fail:
22965 return NULL;
22966 }
22967
22968
22969 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22970 PyObject *resultobj = 0;
22971 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22972 wxSize *arg2 = (wxSize *) 0 ;
22973 void *argp1 = 0 ;
22974 int res1 = 0 ;
22975 void *argp2 = 0 ;
22976 int res2 = 0 ;
22977 PyObject *swig_obj[2] ;
22978
22979 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
22980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22981 if (!SWIG_IsOK(res1)) {
22982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22983 }
22984 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22985 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
22986 if (!SWIG_IsOK(res2)) {
22987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
22988 }
22989 arg2 = reinterpret_cast< wxSize * >(argp2);
22990 if (arg1) (arg1)->m_size = *arg2;
22991
22992 resultobj = SWIG_Py_Void();
22993 return resultobj;
22994 fail:
22995 return NULL;
22996 }
22997
22998
22999 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23000 PyObject *resultobj = 0;
23001 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23002 wxSize *result = 0 ;
23003 void *argp1 = 0 ;
23004 int res1 = 0 ;
23005 PyObject *swig_obj[1] ;
23006
23007 if (!args) SWIG_fail;
23008 swig_obj[0] = args;
23009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23010 if (!SWIG_IsOK(res1)) {
23011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23012 }
23013 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23014 result = (wxSize *)& ((arg1)->m_size);
23015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23016 return resultobj;
23017 fail:
23018 return NULL;
23019 }
23020
23021
23022 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23023 PyObject *resultobj = 0;
23024 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23025 wxRect *arg2 = (wxRect *) 0 ;
23026 void *argp1 = 0 ;
23027 int res1 = 0 ;
23028 void *argp2 = 0 ;
23029 int res2 = 0 ;
23030 PyObject *swig_obj[2] ;
23031
23032 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23034 if (!SWIG_IsOK(res1)) {
23035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23036 }
23037 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23038 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23039 if (!SWIG_IsOK(res2)) {
23040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23041 }
23042 arg2 = reinterpret_cast< wxRect * >(argp2);
23043 if (arg1) (arg1)->m_rect = *arg2;
23044
23045 resultobj = SWIG_Py_Void();
23046 return resultobj;
23047 fail:
23048 return NULL;
23049 }
23050
23051
23052 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23053 PyObject *resultobj = 0;
23054 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23055 wxRect *result = 0 ;
23056 void *argp1 = 0 ;
23057 int res1 = 0 ;
23058 PyObject *swig_obj[1] ;
23059
23060 if (!args) SWIG_fail;
23061 swig_obj[0] = args;
23062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23063 if (!SWIG_IsOK(res1)) {
23064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23065 }
23066 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23067 result = (wxRect *)& ((arg1)->m_rect);
23068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23069 return resultobj;
23070 fail:
23071 return NULL;
23072 }
23073
23074
23075 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23076 PyObject *obj;
23077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23078 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23079 return SWIG_Py_Void();
23080 }
23081
23082 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23083 return SWIG_Python_InitShadowInstance(args);
23084 }
23085
23086 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23087 PyObject *resultobj = 0;
23088 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23089 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23090 int arg2 = (int) 0 ;
23091 wxMoveEvent *result = 0 ;
23092 wxPoint temp1 ;
23093 int val2 ;
23094 int ecode2 = 0 ;
23095 PyObject * obj0 = 0 ;
23096 PyObject * obj1 = 0 ;
23097 char * kwnames[] = {
23098 (char *) "pos",(char *) "winid", NULL
23099 };
23100
23101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23102 if (obj0) {
23103 {
23104 arg1 = &temp1;
23105 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23106 }
23107 }
23108 if (obj1) {
23109 ecode2 = SWIG_AsVal_int(obj1, &val2);
23110 if (!SWIG_IsOK(ecode2)) {
23111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23112 }
23113 arg2 = static_cast< int >(val2);
23114 }
23115 {
23116 PyThreadState* __tstate = wxPyBeginAllowThreads();
23117 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23118 wxPyEndAllowThreads(__tstate);
23119 if (PyErr_Occurred()) SWIG_fail;
23120 }
23121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23122 return resultobj;
23123 fail:
23124 return NULL;
23125 }
23126
23127
23128 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23129 PyObject *resultobj = 0;
23130 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23131 wxPoint result;
23132 void *argp1 = 0 ;
23133 int res1 = 0 ;
23134 PyObject *swig_obj[1] ;
23135
23136 if (!args) SWIG_fail;
23137 swig_obj[0] = args;
23138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23139 if (!SWIG_IsOK(res1)) {
23140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23141 }
23142 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23143 {
23144 PyThreadState* __tstate = wxPyBeginAllowThreads();
23145 result = ((wxMoveEvent const *)arg1)->GetPosition();
23146 wxPyEndAllowThreads(__tstate);
23147 if (PyErr_Occurred()) SWIG_fail;
23148 }
23149 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23150 return resultobj;
23151 fail:
23152 return NULL;
23153 }
23154
23155
23156 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23157 PyObject *resultobj = 0;
23158 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23159 wxRect result;
23160 void *argp1 = 0 ;
23161 int res1 = 0 ;
23162 PyObject *swig_obj[1] ;
23163
23164 if (!args) SWIG_fail;
23165 swig_obj[0] = args;
23166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23167 if (!SWIG_IsOK(res1)) {
23168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23169 }
23170 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23171 {
23172 PyThreadState* __tstate = wxPyBeginAllowThreads();
23173 result = ((wxMoveEvent const *)arg1)->GetRect();
23174 wxPyEndAllowThreads(__tstate);
23175 if (PyErr_Occurred()) SWIG_fail;
23176 }
23177 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23178 return resultobj;
23179 fail:
23180 return NULL;
23181 }
23182
23183
23184 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23185 PyObject *resultobj = 0;
23186 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23187 wxRect *arg2 = 0 ;
23188 void *argp1 = 0 ;
23189 int res1 = 0 ;
23190 wxRect temp2 ;
23191 PyObject * obj0 = 0 ;
23192 PyObject * obj1 = 0 ;
23193 char * kwnames[] = {
23194 (char *) "self",(char *) "rect", NULL
23195 };
23196
23197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23199 if (!SWIG_IsOK(res1)) {
23200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23201 }
23202 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23203 {
23204 arg2 = &temp2;
23205 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23206 }
23207 {
23208 PyThreadState* __tstate = wxPyBeginAllowThreads();
23209 (arg1)->SetRect((wxRect const &)*arg2);
23210 wxPyEndAllowThreads(__tstate);
23211 if (PyErr_Occurred()) SWIG_fail;
23212 }
23213 resultobj = SWIG_Py_Void();
23214 return resultobj;
23215 fail:
23216 return NULL;
23217 }
23218
23219
23220 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23221 PyObject *resultobj = 0;
23222 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23223 wxPoint *arg2 = 0 ;
23224 void *argp1 = 0 ;
23225 int res1 = 0 ;
23226 wxPoint temp2 ;
23227 PyObject * obj0 = 0 ;
23228 PyObject * obj1 = 0 ;
23229 char * kwnames[] = {
23230 (char *) "self",(char *) "pos", NULL
23231 };
23232
23233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23235 if (!SWIG_IsOK(res1)) {
23236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23237 }
23238 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23239 {
23240 arg2 = &temp2;
23241 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23242 }
23243 {
23244 PyThreadState* __tstate = wxPyBeginAllowThreads();
23245 (arg1)->SetPosition((wxPoint const &)*arg2);
23246 wxPyEndAllowThreads(__tstate);
23247 if (PyErr_Occurred()) SWIG_fail;
23248 }
23249 resultobj = SWIG_Py_Void();
23250 return resultobj;
23251 fail:
23252 return NULL;
23253 }
23254
23255
23256 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23257 PyObject *obj;
23258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23259 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23260 return SWIG_Py_Void();
23261 }
23262
23263 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23264 return SWIG_Python_InitShadowInstance(args);
23265 }
23266
23267 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23268 PyObject *resultobj = 0;
23269 int arg1 = (int) 0 ;
23270 wxPaintEvent *result = 0 ;
23271 int val1 ;
23272 int ecode1 = 0 ;
23273 PyObject * obj0 = 0 ;
23274 char * kwnames[] = {
23275 (char *) "Id", NULL
23276 };
23277
23278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23279 if (obj0) {
23280 ecode1 = SWIG_AsVal_int(obj0, &val1);
23281 if (!SWIG_IsOK(ecode1)) {
23282 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23283 }
23284 arg1 = static_cast< int >(val1);
23285 }
23286 {
23287 PyThreadState* __tstate = wxPyBeginAllowThreads();
23288 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23289 wxPyEndAllowThreads(__tstate);
23290 if (PyErr_Occurred()) SWIG_fail;
23291 }
23292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23293 return resultobj;
23294 fail:
23295 return NULL;
23296 }
23297
23298
23299 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23300 PyObject *obj;
23301 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23302 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23303 return SWIG_Py_Void();
23304 }
23305
23306 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23307 return SWIG_Python_InitShadowInstance(args);
23308 }
23309
23310 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23311 PyObject *resultobj = 0;
23312 int arg1 = (int) 0 ;
23313 wxNcPaintEvent *result = 0 ;
23314 int val1 ;
23315 int ecode1 = 0 ;
23316 PyObject * obj0 = 0 ;
23317 char * kwnames[] = {
23318 (char *) "winid", NULL
23319 };
23320
23321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23322 if (obj0) {
23323 ecode1 = SWIG_AsVal_int(obj0, &val1);
23324 if (!SWIG_IsOK(ecode1)) {
23325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23326 }
23327 arg1 = static_cast< int >(val1);
23328 }
23329 {
23330 PyThreadState* __tstate = wxPyBeginAllowThreads();
23331 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23332 wxPyEndAllowThreads(__tstate);
23333 if (PyErr_Occurred()) SWIG_fail;
23334 }
23335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23336 return resultobj;
23337 fail:
23338 return NULL;
23339 }
23340
23341
23342 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23343 PyObject *obj;
23344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23345 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23346 return SWIG_Py_Void();
23347 }
23348
23349 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23350 return SWIG_Python_InitShadowInstance(args);
23351 }
23352
23353 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23354 PyObject *resultobj = 0;
23355 int arg1 = (int) 0 ;
23356 wxDC *arg2 = (wxDC *) NULL ;
23357 wxEraseEvent *result = 0 ;
23358 int val1 ;
23359 int ecode1 = 0 ;
23360 void *argp2 = 0 ;
23361 int res2 = 0 ;
23362 PyObject * obj0 = 0 ;
23363 PyObject * obj1 = 0 ;
23364 char * kwnames[] = {
23365 (char *) "Id",(char *) "dc", NULL
23366 };
23367
23368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23369 if (obj0) {
23370 ecode1 = SWIG_AsVal_int(obj0, &val1);
23371 if (!SWIG_IsOK(ecode1)) {
23372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23373 }
23374 arg1 = static_cast< int >(val1);
23375 }
23376 if (obj1) {
23377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23378 if (!SWIG_IsOK(res2)) {
23379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23380 }
23381 arg2 = reinterpret_cast< wxDC * >(argp2);
23382 }
23383 {
23384 PyThreadState* __tstate = wxPyBeginAllowThreads();
23385 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23386 wxPyEndAllowThreads(__tstate);
23387 if (PyErr_Occurred()) SWIG_fail;
23388 }
23389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23390 return resultobj;
23391 fail:
23392 return NULL;
23393 }
23394
23395
23396 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23397 PyObject *resultobj = 0;
23398 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23399 wxDC *result = 0 ;
23400 void *argp1 = 0 ;
23401 int res1 = 0 ;
23402 PyObject *swig_obj[1] ;
23403
23404 if (!args) SWIG_fail;
23405 swig_obj[0] = args;
23406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23407 if (!SWIG_IsOK(res1)) {
23408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23409 }
23410 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23411 {
23412 PyThreadState* __tstate = wxPyBeginAllowThreads();
23413 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23414 wxPyEndAllowThreads(__tstate);
23415 if (PyErr_Occurred()) SWIG_fail;
23416 }
23417 {
23418 resultobj = wxPyMake_wxObject(result, (bool)0);
23419 }
23420 return resultobj;
23421 fail:
23422 return NULL;
23423 }
23424
23425
23426 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23427 PyObject *obj;
23428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23429 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23430 return SWIG_Py_Void();
23431 }
23432
23433 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23434 return SWIG_Python_InitShadowInstance(args);
23435 }
23436
23437 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23438 PyObject *resultobj = 0;
23439 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23440 int arg2 = (int) 0 ;
23441 wxFocusEvent *result = 0 ;
23442 int val1 ;
23443 int ecode1 = 0 ;
23444 int val2 ;
23445 int ecode2 = 0 ;
23446 PyObject * obj0 = 0 ;
23447 PyObject * obj1 = 0 ;
23448 char * kwnames[] = {
23449 (char *) "type",(char *) "winid", NULL
23450 };
23451
23452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23453 if (obj0) {
23454 ecode1 = SWIG_AsVal_int(obj0, &val1);
23455 if (!SWIG_IsOK(ecode1)) {
23456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23457 }
23458 arg1 = static_cast< wxEventType >(val1);
23459 }
23460 if (obj1) {
23461 ecode2 = SWIG_AsVal_int(obj1, &val2);
23462 if (!SWIG_IsOK(ecode2)) {
23463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23464 }
23465 arg2 = static_cast< int >(val2);
23466 }
23467 {
23468 PyThreadState* __tstate = wxPyBeginAllowThreads();
23469 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23470 wxPyEndAllowThreads(__tstate);
23471 if (PyErr_Occurred()) SWIG_fail;
23472 }
23473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23481 PyObject *resultobj = 0;
23482 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23483 wxWindow *result = 0 ;
23484 void *argp1 = 0 ;
23485 int res1 = 0 ;
23486 PyObject *swig_obj[1] ;
23487
23488 if (!args) SWIG_fail;
23489 swig_obj[0] = args;
23490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23491 if (!SWIG_IsOK(res1)) {
23492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23493 }
23494 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23495 {
23496 PyThreadState* __tstate = wxPyBeginAllowThreads();
23497 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23498 wxPyEndAllowThreads(__tstate);
23499 if (PyErr_Occurred()) SWIG_fail;
23500 }
23501 {
23502 resultobj = wxPyMake_wxObject(result, (bool)0);
23503 }
23504 return resultobj;
23505 fail:
23506 return NULL;
23507 }
23508
23509
23510 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23511 PyObject *resultobj = 0;
23512 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23513 wxWindow *arg2 = (wxWindow *) 0 ;
23514 void *argp1 = 0 ;
23515 int res1 = 0 ;
23516 void *argp2 = 0 ;
23517 int res2 = 0 ;
23518 PyObject * obj0 = 0 ;
23519 PyObject * obj1 = 0 ;
23520 char * kwnames[] = {
23521 (char *) "self",(char *) "win", NULL
23522 };
23523
23524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23526 if (!SWIG_IsOK(res1)) {
23527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23528 }
23529 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23530 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23531 if (!SWIG_IsOK(res2)) {
23532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23533 }
23534 arg2 = reinterpret_cast< wxWindow * >(argp2);
23535 {
23536 PyThreadState* __tstate = wxPyBeginAllowThreads();
23537 (arg1)->SetWindow(arg2);
23538 wxPyEndAllowThreads(__tstate);
23539 if (PyErr_Occurred()) SWIG_fail;
23540 }
23541 resultobj = SWIG_Py_Void();
23542 return resultobj;
23543 fail:
23544 return NULL;
23545 }
23546
23547
23548 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23549 PyObject *obj;
23550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23551 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23552 return SWIG_Py_Void();
23553 }
23554
23555 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23556 return SWIG_Python_InitShadowInstance(args);
23557 }
23558
23559 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23560 PyObject *resultobj = 0;
23561 wxWindow *arg1 = (wxWindow *) NULL ;
23562 wxChildFocusEvent *result = 0 ;
23563 void *argp1 = 0 ;
23564 int res1 = 0 ;
23565 PyObject * obj0 = 0 ;
23566 char * kwnames[] = {
23567 (char *) "win", NULL
23568 };
23569
23570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23571 if (obj0) {
23572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23573 if (!SWIG_IsOK(res1)) {
23574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23575 }
23576 arg1 = reinterpret_cast< wxWindow * >(argp1);
23577 }
23578 {
23579 PyThreadState* __tstate = wxPyBeginAllowThreads();
23580 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23581 wxPyEndAllowThreads(__tstate);
23582 if (PyErr_Occurred()) SWIG_fail;
23583 }
23584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23592 PyObject *resultobj = 0;
23593 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23594 wxWindow *result = 0 ;
23595 void *argp1 = 0 ;
23596 int res1 = 0 ;
23597 PyObject *swig_obj[1] ;
23598
23599 if (!args) SWIG_fail;
23600 swig_obj[0] = args;
23601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23602 if (!SWIG_IsOK(res1)) {
23603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23604 }
23605 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23606 {
23607 PyThreadState* __tstate = wxPyBeginAllowThreads();
23608 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23609 wxPyEndAllowThreads(__tstate);
23610 if (PyErr_Occurred()) SWIG_fail;
23611 }
23612 {
23613 resultobj = wxPyMake_wxObject(result, (bool)0);
23614 }
23615 return resultobj;
23616 fail:
23617 return NULL;
23618 }
23619
23620
23621 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23622 PyObject *obj;
23623 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23624 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23625 return SWIG_Py_Void();
23626 }
23627
23628 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23629 return SWIG_Python_InitShadowInstance(args);
23630 }
23631
23632 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23633 PyObject *resultobj = 0;
23634 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23635 bool arg2 = (bool) true ;
23636 int arg3 = (int) 0 ;
23637 wxActivateEvent *result = 0 ;
23638 int val1 ;
23639 int ecode1 = 0 ;
23640 bool val2 ;
23641 int ecode2 = 0 ;
23642 int val3 ;
23643 int ecode3 = 0 ;
23644 PyObject * obj0 = 0 ;
23645 PyObject * obj1 = 0 ;
23646 PyObject * obj2 = 0 ;
23647 char * kwnames[] = {
23648 (char *) "type",(char *) "active",(char *) "Id", NULL
23649 };
23650
23651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23652 if (obj0) {
23653 ecode1 = SWIG_AsVal_int(obj0, &val1);
23654 if (!SWIG_IsOK(ecode1)) {
23655 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23656 }
23657 arg1 = static_cast< wxEventType >(val1);
23658 }
23659 if (obj1) {
23660 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23661 if (!SWIG_IsOK(ecode2)) {
23662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23663 }
23664 arg2 = static_cast< bool >(val2);
23665 }
23666 if (obj2) {
23667 ecode3 = SWIG_AsVal_int(obj2, &val3);
23668 if (!SWIG_IsOK(ecode3)) {
23669 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23670 }
23671 arg3 = static_cast< int >(val3);
23672 }
23673 {
23674 PyThreadState* __tstate = wxPyBeginAllowThreads();
23675 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23676 wxPyEndAllowThreads(__tstate);
23677 if (PyErr_Occurred()) SWIG_fail;
23678 }
23679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23687 PyObject *resultobj = 0;
23688 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23689 bool result;
23690 void *argp1 = 0 ;
23691 int res1 = 0 ;
23692 PyObject *swig_obj[1] ;
23693
23694 if (!args) SWIG_fail;
23695 swig_obj[0] = args;
23696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23697 if (!SWIG_IsOK(res1)) {
23698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23699 }
23700 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23701 {
23702 PyThreadState* __tstate = wxPyBeginAllowThreads();
23703 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23704 wxPyEndAllowThreads(__tstate);
23705 if (PyErr_Occurred()) SWIG_fail;
23706 }
23707 {
23708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23709 }
23710 return resultobj;
23711 fail:
23712 return NULL;
23713 }
23714
23715
23716 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23717 PyObject *obj;
23718 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23719 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23720 return SWIG_Py_Void();
23721 }
23722
23723 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23724 return SWIG_Python_InitShadowInstance(args);
23725 }
23726
23727 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23728 PyObject *resultobj = 0;
23729 int arg1 = (int) 0 ;
23730 wxInitDialogEvent *result = 0 ;
23731 int val1 ;
23732 int ecode1 = 0 ;
23733 PyObject * obj0 = 0 ;
23734 char * kwnames[] = {
23735 (char *) "Id", NULL
23736 };
23737
23738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23739 if (obj0) {
23740 ecode1 = SWIG_AsVal_int(obj0, &val1);
23741 if (!SWIG_IsOK(ecode1)) {
23742 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23743 }
23744 arg1 = static_cast< int >(val1);
23745 }
23746 {
23747 PyThreadState* __tstate = wxPyBeginAllowThreads();
23748 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23749 wxPyEndAllowThreads(__tstate);
23750 if (PyErr_Occurred()) SWIG_fail;
23751 }
23752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23753 return resultobj;
23754 fail:
23755 return NULL;
23756 }
23757
23758
23759 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23760 PyObject *obj;
23761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23762 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23763 return SWIG_Py_Void();
23764 }
23765
23766 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23767 return SWIG_Python_InitShadowInstance(args);
23768 }
23769
23770 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23771 PyObject *resultobj = 0;
23772 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23773 int arg2 = (int) 0 ;
23774 wxMenu *arg3 = (wxMenu *) NULL ;
23775 wxMenuEvent *result = 0 ;
23776 int val1 ;
23777 int ecode1 = 0 ;
23778 int val2 ;
23779 int ecode2 = 0 ;
23780 void *argp3 = 0 ;
23781 int res3 = 0 ;
23782 PyObject * obj0 = 0 ;
23783 PyObject * obj1 = 0 ;
23784 PyObject * obj2 = 0 ;
23785 char * kwnames[] = {
23786 (char *) "type",(char *) "winid",(char *) "menu", NULL
23787 };
23788
23789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23790 if (obj0) {
23791 ecode1 = SWIG_AsVal_int(obj0, &val1);
23792 if (!SWIG_IsOK(ecode1)) {
23793 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23794 }
23795 arg1 = static_cast< wxEventType >(val1);
23796 }
23797 if (obj1) {
23798 ecode2 = SWIG_AsVal_int(obj1, &val2);
23799 if (!SWIG_IsOK(ecode2)) {
23800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23801 }
23802 arg2 = static_cast< int >(val2);
23803 }
23804 if (obj2) {
23805 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23806 if (!SWIG_IsOK(res3)) {
23807 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23808 }
23809 arg3 = reinterpret_cast< wxMenu * >(argp3);
23810 }
23811 {
23812 PyThreadState* __tstate = wxPyBeginAllowThreads();
23813 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23814 wxPyEndAllowThreads(__tstate);
23815 if (PyErr_Occurred()) SWIG_fail;
23816 }
23817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23818 return resultobj;
23819 fail:
23820 return NULL;
23821 }
23822
23823
23824 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23825 PyObject *resultobj = 0;
23826 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23827 int result;
23828 void *argp1 = 0 ;
23829 int res1 = 0 ;
23830 PyObject *swig_obj[1] ;
23831
23832 if (!args) SWIG_fail;
23833 swig_obj[0] = args;
23834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23835 if (!SWIG_IsOK(res1)) {
23836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23837 }
23838 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 resultobj = SWIG_From_int(static_cast< int >(result));
23846 return resultobj;
23847 fail:
23848 return NULL;
23849 }
23850
23851
23852 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23853 PyObject *resultobj = 0;
23854 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23855 bool result;
23856 void *argp1 = 0 ;
23857 int res1 = 0 ;
23858 PyObject *swig_obj[1] ;
23859
23860 if (!args) SWIG_fail;
23861 swig_obj[0] = args;
23862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23863 if (!SWIG_IsOK(res1)) {
23864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23865 }
23866 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23867 {
23868 PyThreadState* __tstate = wxPyBeginAllowThreads();
23869 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23870 wxPyEndAllowThreads(__tstate);
23871 if (PyErr_Occurred()) SWIG_fail;
23872 }
23873 {
23874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23875 }
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23883 PyObject *resultobj = 0;
23884 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23885 wxMenu *result = 0 ;
23886 void *argp1 = 0 ;
23887 int res1 = 0 ;
23888 PyObject *swig_obj[1] ;
23889
23890 if (!args) SWIG_fail;
23891 swig_obj[0] = args;
23892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23893 if (!SWIG_IsOK(res1)) {
23894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23895 }
23896 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23897 {
23898 PyThreadState* __tstate = wxPyBeginAllowThreads();
23899 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
23900 wxPyEndAllowThreads(__tstate);
23901 if (PyErr_Occurred()) SWIG_fail;
23902 }
23903 {
23904 resultobj = wxPyMake_wxObject(result, (bool)0);
23905 }
23906 return resultobj;
23907 fail:
23908 return NULL;
23909 }
23910
23911
23912 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23913 PyObject *obj;
23914 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23915 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
23916 return SWIG_Py_Void();
23917 }
23918
23919 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23920 return SWIG_Python_InitShadowInstance(args);
23921 }
23922
23923 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23924 PyObject *resultobj = 0;
23925 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23926 int arg2 = (int) 0 ;
23927 wxCloseEvent *result = 0 ;
23928 int val1 ;
23929 int ecode1 = 0 ;
23930 int val2 ;
23931 int ecode2 = 0 ;
23932 PyObject * obj0 = 0 ;
23933 PyObject * obj1 = 0 ;
23934 char * kwnames[] = {
23935 (char *) "type",(char *) "winid", NULL
23936 };
23937
23938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23939 if (obj0) {
23940 ecode1 = SWIG_AsVal_int(obj0, &val1);
23941 if (!SWIG_IsOK(ecode1)) {
23942 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23943 }
23944 arg1 = static_cast< wxEventType >(val1);
23945 }
23946 if (obj1) {
23947 ecode2 = SWIG_AsVal_int(obj1, &val2);
23948 if (!SWIG_IsOK(ecode2)) {
23949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
23950 }
23951 arg2 = static_cast< int >(val2);
23952 }
23953 {
23954 PyThreadState* __tstate = wxPyBeginAllowThreads();
23955 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
23956 wxPyEndAllowThreads(__tstate);
23957 if (PyErr_Occurred()) SWIG_fail;
23958 }
23959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
23960 return resultobj;
23961 fail:
23962 return NULL;
23963 }
23964
23965
23966 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23967 PyObject *resultobj = 0;
23968 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
23969 bool arg2 ;
23970 void *argp1 = 0 ;
23971 int res1 = 0 ;
23972 bool val2 ;
23973 int ecode2 = 0 ;
23974 PyObject * obj0 = 0 ;
23975 PyObject * obj1 = 0 ;
23976 char * kwnames[] = {
23977 (char *) "self",(char *) "logOff", NULL
23978 };
23979
23980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
23981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
23982 if (!SWIG_IsOK(res1)) {
23983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
23984 }
23985 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
23986 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23987 if (!SWIG_IsOK(ecode2)) {
23988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
23989 }
23990 arg2 = static_cast< bool >(val2);
23991 {
23992 PyThreadState* __tstate = wxPyBeginAllowThreads();
23993 (arg1)->SetLoggingOff(arg2);
23994 wxPyEndAllowThreads(__tstate);
23995 if (PyErr_Occurred()) SWIG_fail;
23996 }
23997 resultobj = SWIG_Py_Void();
23998 return resultobj;
23999 fail:
24000 return NULL;
24001 }
24002
24003
24004 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24005 PyObject *resultobj = 0;
24006 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24007 bool result;
24008 void *argp1 = 0 ;
24009 int res1 = 0 ;
24010 PyObject *swig_obj[1] ;
24011
24012 if (!args) SWIG_fail;
24013 swig_obj[0] = args;
24014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24015 if (!SWIG_IsOK(res1)) {
24016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24017 }
24018 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24019 {
24020 PyThreadState* __tstate = wxPyBeginAllowThreads();
24021 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24022 wxPyEndAllowThreads(__tstate);
24023 if (PyErr_Occurred()) SWIG_fail;
24024 }
24025 {
24026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24027 }
24028 return resultobj;
24029 fail:
24030 return NULL;
24031 }
24032
24033
24034 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24035 PyObject *resultobj = 0;
24036 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24037 bool arg2 = (bool) true ;
24038 void *argp1 = 0 ;
24039 int res1 = 0 ;
24040 bool val2 ;
24041 int ecode2 = 0 ;
24042 PyObject * obj0 = 0 ;
24043 PyObject * obj1 = 0 ;
24044 char * kwnames[] = {
24045 (char *) "self",(char *) "veto", NULL
24046 };
24047
24048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24050 if (!SWIG_IsOK(res1)) {
24051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24052 }
24053 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24054 if (obj1) {
24055 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24056 if (!SWIG_IsOK(ecode2)) {
24057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24058 }
24059 arg2 = static_cast< bool >(val2);
24060 }
24061 {
24062 PyThreadState* __tstate = wxPyBeginAllowThreads();
24063 (arg1)->Veto(arg2);
24064 wxPyEndAllowThreads(__tstate);
24065 if (PyErr_Occurred()) SWIG_fail;
24066 }
24067 resultobj = SWIG_Py_Void();
24068 return resultobj;
24069 fail:
24070 return NULL;
24071 }
24072
24073
24074 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24075 PyObject *resultobj = 0;
24076 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24077 bool result;
24078 void *argp1 = 0 ;
24079 int res1 = 0 ;
24080 PyObject *swig_obj[1] ;
24081
24082 if (!args) SWIG_fail;
24083 swig_obj[0] = args;
24084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24085 if (!SWIG_IsOK(res1)) {
24086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24087 }
24088 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24089 {
24090 PyThreadState* __tstate = wxPyBeginAllowThreads();
24091 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24092 wxPyEndAllowThreads(__tstate);
24093 if (PyErr_Occurred()) SWIG_fail;
24094 }
24095 {
24096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24097 }
24098 return resultobj;
24099 fail:
24100 return NULL;
24101 }
24102
24103
24104 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24105 PyObject *resultobj = 0;
24106 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24107 bool arg2 ;
24108 void *argp1 = 0 ;
24109 int res1 = 0 ;
24110 bool val2 ;
24111 int ecode2 = 0 ;
24112 PyObject * obj0 = 0 ;
24113 PyObject * obj1 = 0 ;
24114 char * kwnames[] = {
24115 (char *) "self",(char *) "canVeto", NULL
24116 };
24117
24118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24120 if (!SWIG_IsOK(res1)) {
24121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24122 }
24123 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24124 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24125 if (!SWIG_IsOK(ecode2)) {
24126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24127 }
24128 arg2 = static_cast< bool >(val2);
24129 {
24130 PyThreadState* __tstate = wxPyBeginAllowThreads();
24131 (arg1)->SetCanVeto(arg2);
24132 wxPyEndAllowThreads(__tstate);
24133 if (PyErr_Occurred()) SWIG_fail;
24134 }
24135 resultobj = SWIG_Py_Void();
24136 return resultobj;
24137 fail:
24138 return NULL;
24139 }
24140
24141
24142 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24143 PyObject *resultobj = 0;
24144 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24145 bool result;
24146 void *argp1 = 0 ;
24147 int res1 = 0 ;
24148 PyObject *swig_obj[1] ;
24149
24150 if (!args) SWIG_fail;
24151 swig_obj[0] = args;
24152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24153 if (!SWIG_IsOK(res1)) {
24154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24155 }
24156 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24157 {
24158 PyThreadState* __tstate = wxPyBeginAllowThreads();
24159 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24160 wxPyEndAllowThreads(__tstate);
24161 if (PyErr_Occurred()) SWIG_fail;
24162 }
24163 {
24164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24165 }
24166 return resultobj;
24167 fail:
24168 return NULL;
24169 }
24170
24171
24172 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24173 PyObject *obj;
24174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24175 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24176 return SWIG_Py_Void();
24177 }
24178
24179 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24180 return SWIG_Python_InitShadowInstance(args);
24181 }
24182
24183 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24184 PyObject *resultobj = 0;
24185 int arg1 = (int) 0 ;
24186 bool arg2 = (bool) false ;
24187 wxShowEvent *result = 0 ;
24188 int val1 ;
24189 int ecode1 = 0 ;
24190 bool val2 ;
24191 int ecode2 = 0 ;
24192 PyObject * obj0 = 0 ;
24193 PyObject * obj1 = 0 ;
24194 char * kwnames[] = {
24195 (char *) "winid",(char *) "show", NULL
24196 };
24197
24198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24199 if (obj0) {
24200 ecode1 = SWIG_AsVal_int(obj0, &val1);
24201 if (!SWIG_IsOK(ecode1)) {
24202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24203 }
24204 arg1 = static_cast< int >(val1);
24205 }
24206 if (obj1) {
24207 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24208 if (!SWIG_IsOK(ecode2)) {
24209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24210 }
24211 arg2 = static_cast< bool >(val2);
24212 }
24213 {
24214 PyThreadState* __tstate = wxPyBeginAllowThreads();
24215 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24216 wxPyEndAllowThreads(__tstate);
24217 if (PyErr_Occurred()) SWIG_fail;
24218 }
24219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24220 return resultobj;
24221 fail:
24222 return NULL;
24223 }
24224
24225
24226 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24227 PyObject *resultobj = 0;
24228 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24229 bool arg2 ;
24230 void *argp1 = 0 ;
24231 int res1 = 0 ;
24232 bool val2 ;
24233 int ecode2 = 0 ;
24234 PyObject * obj0 = 0 ;
24235 PyObject * obj1 = 0 ;
24236 char * kwnames[] = {
24237 (char *) "self",(char *) "show", NULL
24238 };
24239
24240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24242 if (!SWIG_IsOK(res1)) {
24243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24244 }
24245 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24246 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24247 if (!SWIG_IsOK(ecode2)) {
24248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24249 }
24250 arg2 = static_cast< bool >(val2);
24251 {
24252 PyThreadState* __tstate = wxPyBeginAllowThreads();
24253 (arg1)->SetShow(arg2);
24254 wxPyEndAllowThreads(__tstate);
24255 if (PyErr_Occurred()) SWIG_fail;
24256 }
24257 resultobj = SWIG_Py_Void();
24258 return resultobj;
24259 fail:
24260 return NULL;
24261 }
24262
24263
24264 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24265 PyObject *resultobj = 0;
24266 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24267 bool result;
24268 void *argp1 = 0 ;
24269 int res1 = 0 ;
24270 PyObject *swig_obj[1] ;
24271
24272 if (!args) SWIG_fail;
24273 swig_obj[0] = args;
24274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24275 if (!SWIG_IsOK(res1)) {
24276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24277 }
24278 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24279 {
24280 PyThreadState* __tstate = wxPyBeginAllowThreads();
24281 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24282 wxPyEndAllowThreads(__tstate);
24283 if (PyErr_Occurred()) SWIG_fail;
24284 }
24285 {
24286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24287 }
24288 return resultobj;
24289 fail:
24290 return NULL;
24291 }
24292
24293
24294 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24295 PyObject *obj;
24296 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24297 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24298 return SWIG_Py_Void();
24299 }
24300
24301 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24302 return SWIG_Python_InitShadowInstance(args);
24303 }
24304
24305 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24306 PyObject *resultobj = 0;
24307 int arg1 = (int) 0 ;
24308 bool arg2 = (bool) true ;
24309 wxIconizeEvent *result = 0 ;
24310 int val1 ;
24311 int ecode1 = 0 ;
24312 bool val2 ;
24313 int ecode2 = 0 ;
24314 PyObject * obj0 = 0 ;
24315 PyObject * obj1 = 0 ;
24316 char * kwnames[] = {
24317 (char *) "id",(char *) "iconized", NULL
24318 };
24319
24320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24321 if (obj0) {
24322 ecode1 = SWIG_AsVal_int(obj0, &val1);
24323 if (!SWIG_IsOK(ecode1)) {
24324 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24325 }
24326 arg1 = static_cast< int >(val1);
24327 }
24328 if (obj1) {
24329 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24330 if (!SWIG_IsOK(ecode2)) {
24331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24332 }
24333 arg2 = static_cast< bool >(val2);
24334 }
24335 {
24336 PyThreadState* __tstate = wxPyBeginAllowThreads();
24337 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24338 wxPyEndAllowThreads(__tstate);
24339 if (PyErr_Occurred()) SWIG_fail;
24340 }
24341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24342 return resultobj;
24343 fail:
24344 return NULL;
24345 }
24346
24347
24348 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24349 PyObject *resultobj = 0;
24350 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24351 bool result;
24352 void *argp1 = 0 ;
24353 int res1 = 0 ;
24354 PyObject *swig_obj[1] ;
24355
24356 if (!args) SWIG_fail;
24357 swig_obj[0] = args;
24358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24359 if (!SWIG_IsOK(res1)) {
24360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24361 }
24362 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24363 {
24364 PyThreadState* __tstate = wxPyBeginAllowThreads();
24365 result = (bool)(arg1)->Iconized();
24366 wxPyEndAllowThreads(__tstate);
24367 if (PyErr_Occurred()) SWIG_fail;
24368 }
24369 {
24370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24371 }
24372 return resultobj;
24373 fail:
24374 return NULL;
24375 }
24376
24377
24378 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24379 PyObject *obj;
24380 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24381 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24382 return SWIG_Py_Void();
24383 }
24384
24385 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24386 return SWIG_Python_InitShadowInstance(args);
24387 }
24388
24389 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24390 PyObject *resultobj = 0;
24391 int arg1 = (int) 0 ;
24392 wxMaximizeEvent *result = 0 ;
24393 int val1 ;
24394 int ecode1 = 0 ;
24395 PyObject * obj0 = 0 ;
24396 char * kwnames[] = {
24397 (char *) "id", NULL
24398 };
24399
24400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24401 if (obj0) {
24402 ecode1 = SWIG_AsVal_int(obj0, &val1);
24403 if (!SWIG_IsOK(ecode1)) {
24404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24405 }
24406 arg1 = static_cast< int >(val1);
24407 }
24408 {
24409 PyThreadState* __tstate = wxPyBeginAllowThreads();
24410 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24411 wxPyEndAllowThreads(__tstate);
24412 if (PyErr_Occurred()) SWIG_fail;
24413 }
24414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24415 return resultobj;
24416 fail:
24417 return NULL;
24418 }
24419
24420
24421 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24422 PyObject *obj;
24423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24424 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24425 return SWIG_Py_Void();
24426 }
24427
24428 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24429 return SWIG_Python_InitShadowInstance(args);
24430 }
24431
24432 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24433 PyObject *resultobj = 0;
24434 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24435 wxPoint result;
24436 void *argp1 = 0 ;
24437 int res1 = 0 ;
24438 PyObject *swig_obj[1] ;
24439
24440 if (!args) SWIG_fail;
24441 swig_obj[0] = args;
24442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24443 if (!SWIG_IsOK(res1)) {
24444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24445 }
24446 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24447 {
24448 PyThreadState* __tstate = wxPyBeginAllowThreads();
24449 result = (arg1)->GetPosition();
24450 wxPyEndAllowThreads(__tstate);
24451 if (PyErr_Occurred()) SWIG_fail;
24452 }
24453 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24454 return resultobj;
24455 fail:
24456 return NULL;
24457 }
24458
24459
24460 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24461 PyObject *resultobj = 0;
24462 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24463 int result;
24464 void *argp1 = 0 ;
24465 int res1 = 0 ;
24466 PyObject *swig_obj[1] ;
24467
24468 if (!args) SWIG_fail;
24469 swig_obj[0] = args;
24470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24471 if (!SWIG_IsOK(res1)) {
24472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24473 }
24474 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24475 {
24476 PyThreadState* __tstate = wxPyBeginAllowThreads();
24477 result = (int)(arg1)->GetNumberOfFiles();
24478 wxPyEndAllowThreads(__tstate);
24479 if (PyErr_Occurred()) SWIG_fail;
24480 }
24481 resultobj = SWIG_From_int(static_cast< int >(result));
24482 return resultobj;
24483 fail:
24484 return NULL;
24485 }
24486
24487
24488 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24489 PyObject *resultobj = 0;
24490 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24491 PyObject *result = 0 ;
24492 void *argp1 = 0 ;
24493 int res1 = 0 ;
24494 PyObject *swig_obj[1] ;
24495
24496 if (!args) SWIG_fail;
24497 swig_obj[0] = args;
24498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24499 if (!SWIG_IsOK(res1)) {
24500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24501 }
24502 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24503 {
24504 PyThreadState* __tstate = wxPyBeginAllowThreads();
24505 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24506 wxPyEndAllowThreads(__tstate);
24507 if (PyErr_Occurred()) SWIG_fail;
24508 }
24509 resultobj = result;
24510 return resultobj;
24511 fail:
24512 return NULL;
24513 }
24514
24515
24516 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24517 PyObject *obj;
24518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24519 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24520 return SWIG_Py_Void();
24521 }
24522
24523 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24524 PyObject *resultobj = 0;
24525 int arg1 = (int) 0 ;
24526 wxUpdateUIEvent *result = 0 ;
24527 int val1 ;
24528 int ecode1 = 0 ;
24529 PyObject * obj0 = 0 ;
24530 char * kwnames[] = {
24531 (char *) "commandId", NULL
24532 };
24533
24534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24535 if (obj0) {
24536 ecode1 = SWIG_AsVal_int(obj0, &val1);
24537 if (!SWIG_IsOK(ecode1)) {
24538 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24539 }
24540 arg1 = static_cast< int >(val1);
24541 }
24542 {
24543 PyThreadState* __tstate = wxPyBeginAllowThreads();
24544 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24545 wxPyEndAllowThreads(__tstate);
24546 if (PyErr_Occurred()) SWIG_fail;
24547 }
24548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24549 return resultobj;
24550 fail:
24551 return NULL;
24552 }
24553
24554
24555 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24556 PyObject *resultobj = 0;
24557 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24558 bool result;
24559 void *argp1 = 0 ;
24560 int res1 = 0 ;
24561 PyObject *swig_obj[1] ;
24562
24563 if (!args) SWIG_fail;
24564 swig_obj[0] = args;
24565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24566 if (!SWIG_IsOK(res1)) {
24567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24568 }
24569 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24570 {
24571 PyThreadState* __tstate = wxPyBeginAllowThreads();
24572 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24573 wxPyEndAllowThreads(__tstate);
24574 if (PyErr_Occurred()) SWIG_fail;
24575 }
24576 {
24577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24578 }
24579 return resultobj;
24580 fail:
24581 return NULL;
24582 }
24583
24584
24585 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24586 PyObject *resultobj = 0;
24587 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24588 bool result;
24589 void *argp1 = 0 ;
24590 int res1 = 0 ;
24591 PyObject *swig_obj[1] ;
24592
24593 if (!args) SWIG_fail;
24594 swig_obj[0] = args;
24595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24596 if (!SWIG_IsOK(res1)) {
24597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24598 }
24599 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24600 {
24601 PyThreadState* __tstate = wxPyBeginAllowThreads();
24602 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24603 wxPyEndAllowThreads(__tstate);
24604 if (PyErr_Occurred()) SWIG_fail;
24605 }
24606 {
24607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24608 }
24609 return resultobj;
24610 fail:
24611 return NULL;
24612 }
24613
24614
24615 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24616 PyObject *resultobj = 0;
24617 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24618 bool result;
24619 void *argp1 = 0 ;
24620 int res1 = 0 ;
24621 PyObject *swig_obj[1] ;
24622
24623 if (!args) SWIG_fail;
24624 swig_obj[0] = args;
24625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24626 if (!SWIG_IsOK(res1)) {
24627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24628 }
24629 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24630 {
24631 PyThreadState* __tstate = wxPyBeginAllowThreads();
24632 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24633 wxPyEndAllowThreads(__tstate);
24634 if (PyErr_Occurred()) SWIG_fail;
24635 }
24636 {
24637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24638 }
24639 return resultobj;
24640 fail:
24641 return NULL;
24642 }
24643
24644
24645 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24646 PyObject *resultobj = 0;
24647 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24648 wxString result;
24649 void *argp1 = 0 ;
24650 int res1 = 0 ;
24651 PyObject *swig_obj[1] ;
24652
24653 if (!args) SWIG_fail;
24654 swig_obj[0] = args;
24655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24656 if (!SWIG_IsOK(res1)) {
24657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24658 }
24659 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24660 {
24661 PyThreadState* __tstate = wxPyBeginAllowThreads();
24662 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24663 wxPyEndAllowThreads(__tstate);
24664 if (PyErr_Occurred()) SWIG_fail;
24665 }
24666 {
24667 #if wxUSE_UNICODE
24668 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24669 #else
24670 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24671 #endif
24672 }
24673 return resultobj;
24674 fail:
24675 return NULL;
24676 }
24677
24678
24679 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24680 PyObject *resultobj = 0;
24681 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24682 bool result;
24683 void *argp1 = 0 ;
24684 int res1 = 0 ;
24685 PyObject *swig_obj[1] ;
24686
24687 if (!args) SWIG_fail;
24688 swig_obj[0] = args;
24689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24690 if (!SWIG_IsOK(res1)) {
24691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24692 }
24693 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24694 {
24695 PyThreadState* __tstate = wxPyBeginAllowThreads();
24696 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24697 wxPyEndAllowThreads(__tstate);
24698 if (PyErr_Occurred()) SWIG_fail;
24699 }
24700 {
24701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24702 }
24703 return resultobj;
24704 fail:
24705 return NULL;
24706 }
24707
24708
24709 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24710 PyObject *resultobj = 0;
24711 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24712 bool result;
24713 void *argp1 = 0 ;
24714 int res1 = 0 ;
24715 PyObject *swig_obj[1] ;
24716
24717 if (!args) SWIG_fail;
24718 swig_obj[0] = args;
24719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24720 if (!SWIG_IsOK(res1)) {
24721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24722 }
24723 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24724 {
24725 PyThreadState* __tstate = wxPyBeginAllowThreads();
24726 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24727 wxPyEndAllowThreads(__tstate);
24728 if (PyErr_Occurred()) SWIG_fail;
24729 }
24730 {
24731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24732 }
24733 return resultobj;
24734 fail:
24735 return NULL;
24736 }
24737
24738
24739 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24740 PyObject *resultobj = 0;
24741 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24742 bool result;
24743 void *argp1 = 0 ;
24744 int res1 = 0 ;
24745 PyObject *swig_obj[1] ;
24746
24747 if (!args) SWIG_fail;
24748 swig_obj[0] = args;
24749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24750 if (!SWIG_IsOK(res1)) {
24751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24752 }
24753 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24754 {
24755 PyThreadState* __tstate = wxPyBeginAllowThreads();
24756 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24757 wxPyEndAllowThreads(__tstate);
24758 if (PyErr_Occurred()) SWIG_fail;
24759 }
24760 {
24761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24762 }
24763 return resultobj;
24764 fail:
24765 return NULL;
24766 }
24767
24768
24769 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24770 PyObject *resultobj = 0;
24771 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24772 bool result;
24773 void *argp1 = 0 ;
24774 int res1 = 0 ;
24775 PyObject *swig_obj[1] ;
24776
24777 if (!args) SWIG_fail;
24778 swig_obj[0] = args;
24779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24780 if (!SWIG_IsOK(res1)) {
24781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24782 }
24783 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24784 {
24785 PyThreadState* __tstate = wxPyBeginAllowThreads();
24786 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24787 wxPyEndAllowThreads(__tstate);
24788 if (PyErr_Occurred()) SWIG_fail;
24789 }
24790 {
24791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24792 }
24793 return resultobj;
24794 fail:
24795 return NULL;
24796 }
24797
24798
24799 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24800 PyObject *resultobj = 0;
24801 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24802 bool arg2 ;
24803 void *argp1 = 0 ;
24804 int res1 = 0 ;
24805 bool val2 ;
24806 int ecode2 = 0 ;
24807 PyObject * obj0 = 0 ;
24808 PyObject * obj1 = 0 ;
24809 char * kwnames[] = {
24810 (char *) "self",(char *) "check", NULL
24811 };
24812
24813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24815 if (!SWIG_IsOK(res1)) {
24816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24817 }
24818 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24819 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24820 if (!SWIG_IsOK(ecode2)) {
24821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24822 }
24823 arg2 = static_cast< bool >(val2);
24824 {
24825 PyThreadState* __tstate = wxPyBeginAllowThreads();
24826 (arg1)->Check(arg2);
24827 wxPyEndAllowThreads(__tstate);
24828 if (PyErr_Occurred()) SWIG_fail;
24829 }
24830 resultobj = SWIG_Py_Void();
24831 return resultobj;
24832 fail:
24833 return NULL;
24834 }
24835
24836
24837 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24838 PyObject *resultobj = 0;
24839 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24840 bool arg2 ;
24841 void *argp1 = 0 ;
24842 int res1 = 0 ;
24843 bool val2 ;
24844 int ecode2 = 0 ;
24845 PyObject * obj0 = 0 ;
24846 PyObject * obj1 = 0 ;
24847 char * kwnames[] = {
24848 (char *) "self",(char *) "enable", NULL
24849 };
24850
24851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24853 if (!SWIG_IsOK(res1)) {
24854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24855 }
24856 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24857 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24858 if (!SWIG_IsOK(ecode2)) {
24859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24860 }
24861 arg2 = static_cast< bool >(val2);
24862 {
24863 PyThreadState* __tstate = wxPyBeginAllowThreads();
24864 (arg1)->Enable(arg2);
24865 wxPyEndAllowThreads(__tstate);
24866 if (PyErr_Occurred()) SWIG_fail;
24867 }
24868 resultobj = SWIG_Py_Void();
24869 return resultobj;
24870 fail:
24871 return NULL;
24872 }
24873
24874
24875 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24876 PyObject *resultobj = 0;
24877 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24878 bool arg2 ;
24879 void *argp1 = 0 ;
24880 int res1 = 0 ;
24881 bool val2 ;
24882 int ecode2 = 0 ;
24883 PyObject * obj0 = 0 ;
24884 PyObject * obj1 = 0 ;
24885 char * kwnames[] = {
24886 (char *) "self",(char *) "show", NULL
24887 };
24888
24889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24891 if (!SWIG_IsOK(res1)) {
24892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24893 }
24894 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24895 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24896 if (!SWIG_IsOK(ecode2)) {
24897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
24898 }
24899 arg2 = static_cast< bool >(val2);
24900 {
24901 PyThreadState* __tstate = wxPyBeginAllowThreads();
24902 (arg1)->Show(arg2);
24903 wxPyEndAllowThreads(__tstate);
24904 if (PyErr_Occurred()) SWIG_fail;
24905 }
24906 resultobj = SWIG_Py_Void();
24907 return resultobj;
24908 fail:
24909 return NULL;
24910 }
24911
24912
24913 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24914 PyObject *resultobj = 0;
24915 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24916 wxString *arg2 = 0 ;
24917 void *argp1 = 0 ;
24918 int res1 = 0 ;
24919 bool temp2 = false ;
24920 PyObject * obj0 = 0 ;
24921 PyObject * obj1 = 0 ;
24922 char * kwnames[] = {
24923 (char *) "self",(char *) "text", NULL
24924 };
24925
24926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
24927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24928 if (!SWIG_IsOK(res1)) {
24929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24930 }
24931 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24932 {
24933 arg2 = wxString_in_helper(obj1);
24934 if (arg2 == NULL) SWIG_fail;
24935 temp2 = true;
24936 }
24937 {
24938 PyThreadState* __tstate = wxPyBeginAllowThreads();
24939 (arg1)->SetText((wxString const &)*arg2);
24940 wxPyEndAllowThreads(__tstate);
24941 if (PyErr_Occurred()) SWIG_fail;
24942 }
24943 resultobj = SWIG_Py_Void();
24944 {
24945 if (temp2)
24946 delete arg2;
24947 }
24948 return resultobj;
24949 fail:
24950 {
24951 if (temp2)
24952 delete arg2;
24953 }
24954 return NULL;
24955 }
24956
24957
24958 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24959 PyObject *resultobj = 0;
24960 long arg1 ;
24961 long val1 ;
24962 int ecode1 = 0 ;
24963 PyObject * obj0 = 0 ;
24964 char * kwnames[] = {
24965 (char *) "updateInterval", NULL
24966 };
24967
24968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
24969 ecode1 = SWIG_AsVal_long(obj0, &val1);
24970 if (!SWIG_IsOK(ecode1)) {
24971 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
24972 }
24973 arg1 = static_cast< long >(val1);
24974 {
24975 PyThreadState* __tstate = wxPyBeginAllowThreads();
24976 wxUpdateUIEvent::SetUpdateInterval(arg1);
24977 wxPyEndAllowThreads(__tstate);
24978 if (PyErr_Occurred()) SWIG_fail;
24979 }
24980 resultobj = SWIG_Py_Void();
24981 return resultobj;
24982 fail:
24983 return NULL;
24984 }
24985
24986
24987 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24988 PyObject *resultobj = 0;
24989 long result;
24990
24991 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
24992 {
24993 PyThreadState* __tstate = wxPyBeginAllowThreads();
24994 result = (long)wxUpdateUIEvent::GetUpdateInterval();
24995 wxPyEndAllowThreads(__tstate);
24996 if (PyErr_Occurred()) SWIG_fail;
24997 }
24998 resultobj = SWIG_From_long(static_cast< long >(result));
24999 return resultobj;
25000 fail:
25001 return NULL;
25002 }
25003
25004
25005 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25006 PyObject *resultobj = 0;
25007 wxWindow *arg1 = (wxWindow *) 0 ;
25008 bool result;
25009 void *argp1 = 0 ;
25010 int res1 = 0 ;
25011 PyObject * obj0 = 0 ;
25012 char * kwnames[] = {
25013 (char *) "win", NULL
25014 };
25015
25016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25018 if (!SWIG_IsOK(res1)) {
25019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25020 }
25021 arg1 = reinterpret_cast< wxWindow * >(argp1);
25022 {
25023 PyThreadState* __tstate = wxPyBeginAllowThreads();
25024 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25025 wxPyEndAllowThreads(__tstate);
25026 if (PyErr_Occurred()) SWIG_fail;
25027 }
25028 {
25029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25030 }
25031 return resultobj;
25032 fail:
25033 return NULL;
25034 }
25035
25036
25037 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25038 PyObject *resultobj = 0;
25039
25040 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25041 {
25042 PyThreadState* __tstate = wxPyBeginAllowThreads();
25043 wxUpdateUIEvent::ResetUpdateTime();
25044 wxPyEndAllowThreads(__tstate);
25045 if (PyErr_Occurred()) SWIG_fail;
25046 }
25047 resultobj = SWIG_Py_Void();
25048 return resultobj;
25049 fail:
25050 return NULL;
25051 }
25052
25053
25054 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25055 PyObject *resultobj = 0;
25056 wxUpdateUIMode arg1 ;
25057 int val1 ;
25058 int ecode1 = 0 ;
25059 PyObject * obj0 = 0 ;
25060 char * kwnames[] = {
25061 (char *) "mode", NULL
25062 };
25063
25064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25065 ecode1 = SWIG_AsVal_int(obj0, &val1);
25066 if (!SWIG_IsOK(ecode1)) {
25067 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25068 }
25069 arg1 = static_cast< wxUpdateUIMode >(val1);
25070 {
25071 PyThreadState* __tstate = wxPyBeginAllowThreads();
25072 wxUpdateUIEvent::SetMode(arg1);
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_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25084 PyObject *resultobj = 0;
25085 wxUpdateUIMode result;
25086
25087 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25088 {
25089 PyThreadState* __tstate = wxPyBeginAllowThreads();
25090 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 resultobj = SWIG_From_int(static_cast< int >(result));
25095 return resultobj;
25096 fail:
25097 return NULL;
25098 }
25099
25100
25101 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25102 PyObject *obj;
25103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25104 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25105 return SWIG_Py_Void();
25106 }
25107
25108 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25109 return SWIG_Python_InitShadowInstance(args);
25110 }
25111
25112 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25113 PyObject *resultobj = 0;
25114 wxSysColourChangedEvent *result = 0 ;
25115
25116 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25117 {
25118 PyThreadState* __tstate = wxPyBeginAllowThreads();
25119 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25120 wxPyEndAllowThreads(__tstate);
25121 if (PyErr_Occurred()) SWIG_fail;
25122 }
25123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25124 return resultobj;
25125 fail:
25126 return NULL;
25127 }
25128
25129
25130 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25131 PyObject *obj;
25132 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25133 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25134 return SWIG_Py_Void();
25135 }
25136
25137 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25138 return SWIG_Python_InitShadowInstance(args);
25139 }
25140
25141 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25142 PyObject *resultobj = 0;
25143 int arg1 = (int) 0 ;
25144 wxWindow *arg2 = (wxWindow *) NULL ;
25145 wxMouseCaptureChangedEvent *result = 0 ;
25146 int val1 ;
25147 int ecode1 = 0 ;
25148 void *argp2 = 0 ;
25149 int res2 = 0 ;
25150 PyObject * obj0 = 0 ;
25151 PyObject * obj1 = 0 ;
25152 char * kwnames[] = {
25153 (char *) "winid",(char *) "gainedCapture", NULL
25154 };
25155
25156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25157 if (obj0) {
25158 ecode1 = SWIG_AsVal_int(obj0, &val1);
25159 if (!SWIG_IsOK(ecode1)) {
25160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25161 }
25162 arg1 = static_cast< int >(val1);
25163 }
25164 if (obj1) {
25165 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25166 if (!SWIG_IsOK(res2)) {
25167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25168 }
25169 arg2 = reinterpret_cast< wxWindow * >(argp2);
25170 }
25171 {
25172 PyThreadState* __tstate = wxPyBeginAllowThreads();
25173 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25174 wxPyEndAllowThreads(__tstate);
25175 if (PyErr_Occurred()) SWIG_fail;
25176 }
25177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25178 return resultobj;
25179 fail:
25180 return NULL;
25181 }
25182
25183
25184 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25185 PyObject *resultobj = 0;
25186 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25187 wxWindow *result = 0 ;
25188 void *argp1 = 0 ;
25189 int res1 = 0 ;
25190 PyObject *swig_obj[1] ;
25191
25192 if (!args) SWIG_fail;
25193 swig_obj[0] = args;
25194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25195 if (!SWIG_IsOK(res1)) {
25196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25197 }
25198 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25199 {
25200 PyThreadState* __tstate = wxPyBeginAllowThreads();
25201 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25202 wxPyEndAllowThreads(__tstate);
25203 if (PyErr_Occurred()) SWIG_fail;
25204 }
25205 {
25206 resultobj = wxPyMake_wxObject(result, (bool)0);
25207 }
25208 return resultobj;
25209 fail:
25210 return NULL;
25211 }
25212
25213
25214 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25215 PyObject *obj;
25216 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25217 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25218 return SWIG_Py_Void();
25219 }
25220
25221 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25222 return SWIG_Python_InitShadowInstance(args);
25223 }
25224
25225 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25226 PyObject *resultobj = 0;
25227 wxDisplayChangedEvent *result = 0 ;
25228
25229 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25230 {
25231 PyThreadState* __tstate = wxPyBeginAllowThreads();
25232 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25233 wxPyEndAllowThreads(__tstate);
25234 if (PyErr_Occurred()) SWIG_fail;
25235 }
25236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25237 return resultobj;
25238 fail:
25239 return NULL;
25240 }
25241
25242
25243 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25244 PyObject *obj;
25245 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25246 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25247 return SWIG_Py_Void();
25248 }
25249
25250 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25251 return SWIG_Python_InitShadowInstance(args);
25252 }
25253
25254 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25255 PyObject *resultobj = 0;
25256 int arg1 = (int) 0 ;
25257 wxPaletteChangedEvent *result = 0 ;
25258 int val1 ;
25259 int ecode1 = 0 ;
25260 PyObject * obj0 = 0 ;
25261 char * kwnames[] = {
25262 (char *) "id", NULL
25263 };
25264
25265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25266 if (obj0) {
25267 ecode1 = SWIG_AsVal_int(obj0, &val1);
25268 if (!SWIG_IsOK(ecode1)) {
25269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25270 }
25271 arg1 = static_cast< int >(val1);
25272 }
25273 {
25274 PyThreadState* __tstate = wxPyBeginAllowThreads();
25275 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25276 wxPyEndAllowThreads(__tstate);
25277 if (PyErr_Occurred()) SWIG_fail;
25278 }
25279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25280 return resultobj;
25281 fail:
25282 return NULL;
25283 }
25284
25285
25286 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25287 PyObject *resultobj = 0;
25288 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25289 wxWindow *arg2 = (wxWindow *) 0 ;
25290 void *argp1 = 0 ;
25291 int res1 = 0 ;
25292 void *argp2 = 0 ;
25293 int res2 = 0 ;
25294 PyObject * obj0 = 0 ;
25295 PyObject * obj1 = 0 ;
25296 char * kwnames[] = {
25297 (char *) "self",(char *) "win", NULL
25298 };
25299
25300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25302 if (!SWIG_IsOK(res1)) {
25303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25304 }
25305 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25306 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25307 if (!SWIG_IsOK(res2)) {
25308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25309 }
25310 arg2 = reinterpret_cast< wxWindow * >(argp2);
25311 {
25312 PyThreadState* __tstate = wxPyBeginAllowThreads();
25313 (arg1)->SetChangedWindow(arg2);
25314 wxPyEndAllowThreads(__tstate);
25315 if (PyErr_Occurred()) SWIG_fail;
25316 }
25317 resultobj = SWIG_Py_Void();
25318 return resultobj;
25319 fail:
25320 return NULL;
25321 }
25322
25323
25324 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25325 PyObject *resultobj = 0;
25326 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25327 wxWindow *result = 0 ;
25328 void *argp1 = 0 ;
25329 int res1 = 0 ;
25330 PyObject *swig_obj[1] ;
25331
25332 if (!args) SWIG_fail;
25333 swig_obj[0] = args;
25334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25335 if (!SWIG_IsOK(res1)) {
25336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25337 }
25338 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25339 {
25340 PyThreadState* __tstate = wxPyBeginAllowThreads();
25341 result = (wxWindow *)(arg1)->GetChangedWindow();
25342 wxPyEndAllowThreads(__tstate);
25343 if (PyErr_Occurred()) SWIG_fail;
25344 }
25345 {
25346 resultobj = wxPyMake_wxObject(result, (bool)0);
25347 }
25348 return resultobj;
25349 fail:
25350 return NULL;
25351 }
25352
25353
25354 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25355 PyObject *obj;
25356 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25357 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25358 return SWIG_Py_Void();
25359 }
25360
25361 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25362 return SWIG_Python_InitShadowInstance(args);
25363 }
25364
25365 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25366 PyObject *resultobj = 0;
25367 int arg1 = (int) 0 ;
25368 wxQueryNewPaletteEvent *result = 0 ;
25369 int val1 ;
25370 int ecode1 = 0 ;
25371 PyObject * obj0 = 0 ;
25372 char * kwnames[] = {
25373 (char *) "winid", NULL
25374 };
25375
25376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25377 if (obj0) {
25378 ecode1 = SWIG_AsVal_int(obj0, &val1);
25379 if (!SWIG_IsOK(ecode1)) {
25380 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25381 }
25382 arg1 = static_cast< int >(val1);
25383 }
25384 {
25385 PyThreadState* __tstate = wxPyBeginAllowThreads();
25386 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25387 wxPyEndAllowThreads(__tstate);
25388 if (PyErr_Occurred()) SWIG_fail;
25389 }
25390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25391 return resultobj;
25392 fail:
25393 return NULL;
25394 }
25395
25396
25397 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25398 PyObject *resultobj = 0;
25399 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25400 bool arg2 ;
25401 void *argp1 = 0 ;
25402 int res1 = 0 ;
25403 bool val2 ;
25404 int ecode2 = 0 ;
25405 PyObject * obj0 = 0 ;
25406 PyObject * obj1 = 0 ;
25407 char * kwnames[] = {
25408 (char *) "self",(char *) "realized", NULL
25409 };
25410
25411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25413 if (!SWIG_IsOK(res1)) {
25414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25415 }
25416 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25417 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25418 if (!SWIG_IsOK(ecode2)) {
25419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25420 }
25421 arg2 = static_cast< bool >(val2);
25422 {
25423 PyThreadState* __tstate = wxPyBeginAllowThreads();
25424 (arg1)->SetPaletteRealized(arg2);
25425 wxPyEndAllowThreads(__tstate);
25426 if (PyErr_Occurred()) SWIG_fail;
25427 }
25428 resultobj = SWIG_Py_Void();
25429 return resultobj;
25430 fail:
25431 return NULL;
25432 }
25433
25434
25435 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25436 PyObject *resultobj = 0;
25437 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25438 bool result;
25439 void *argp1 = 0 ;
25440 int res1 = 0 ;
25441 PyObject *swig_obj[1] ;
25442
25443 if (!args) SWIG_fail;
25444 swig_obj[0] = args;
25445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25446 if (!SWIG_IsOK(res1)) {
25447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25448 }
25449 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25450 {
25451 PyThreadState* __tstate = wxPyBeginAllowThreads();
25452 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25453 wxPyEndAllowThreads(__tstate);
25454 if (PyErr_Occurred()) SWIG_fail;
25455 }
25456 {
25457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25458 }
25459 return resultobj;
25460 fail:
25461 return NULL;
25462 }
25463
25464
25465 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25466 PyObject *obj;
25467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25468 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25469 return SWIG_Py_Void();
25470 }
25471
25472 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25473 return SWIG_Python_InitShadowInstance(args);
25474 }
25475
25476 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25477 PyObject *resultobj = 0;
25478 wxNavigationKeyEvent *result = 0 ;
25479
25480 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25481 {
25482 PyThreadState* __tstate = wxPyBeginAllowThreads();
25483 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25484 wxPyEndAllowThreads(__tstate);
25485 if (PyErr_Occurred()) SWIG_fail;
25486 }
25487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25488 return resultobj;
25489 fail:
25490 return NULL;
25491 }
25492
25493
25494 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25495 PyObject *resultobj = 0;
25496 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25497 bool result;
25498 void *argp1 = 0 ;
25499 int res1 = 0 ;
25500 PyObject *swig_obj[1] ;
25501
25502 if (!args) SWIG_fail;
25503 swig_obj[0] = args;
25504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25505 if (!SWIG_IsOK(res1)) {
25506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25507 }
25508 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25509 {
25510 PyThreadState* __tstate = wxPyBeginAllowThreads();
25511 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25512 wxPyEndAllowThreads(__tstate);
25513 if (PyErr_Occurred()) SWIG_fail;
25514 }
25515 {
25516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25517 }
25518 return resultobj;
25519 fail:
25520 return NULL;
25521 }
25522
25523
25524 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25525 PyObject *resultobj = 0;
25526 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25527 bool arg2 ;
25528 void *argp1 = 0 ;
25529 int res1 = 0 ;
25530 bool val2 ;
25531 int ecode2 = 0 ;
25532 PyObject * obj0 = 0 ;
25533 PyObject * obj1 = 0 ;
25534 char * kwnames[] = {
25535 (char *) "self",(char *) "forward", NULL
25536 };
25537
25538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25540 if (!SWIG_IsOK(res1)) {
25541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25542 }
25543 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25544 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25545 if (!SWIG_IsOK(ecode2)) {
25546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25547 }
25548 arg2 = static_cast< bool >(val2);
25549 {
25550 PyThreadState* __tstate = wxPyBeginAllowThreads();
25551 (arg1)->SetDirection(arg2);
25552 wxPyEndAllowThreads(__tstate);
25553 if (PyErr_Occurred()) SWIG_fail;
25554 }
25555 resultobj = SWIG_Py_Void();
25556 return resultobj;
25557 fail:
25558 return NULL;
25559 }
25560
25561
25562 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25563 PyObject *resultobj = 0;
25564 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25565 bool result;
25566 void *argp1 = 0 ;
25567 int res1 = 0 ;
25568 PyObject *swig_obj[1] ;
25569
25570 if (!args) SWIG_fail;
25571 swig_obj[0] = args;
25572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25573 if (!SWIG_IsOK(res1)) {
25574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25575 }
25576 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25577 {
25578 PyThreadState* __tstate = wxPyBeginAllowThreads();
25579 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25580 wxPyEndAllowThreads(__tstate);
25581 if (PyErr_Occurred()) SWIG_fail;
25582 }
25583 {
25584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25585 }
25586 return resultobj;
25587 fail:
25588 return NULL;
25589 }
25590
25591
25592 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25593 PyObject *resultobj = 0;
25594 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25595 bool arg2 ;
25596 void *argp1 = 0 ;
25597 int res1 = 0 ;
25598 bool val2 ;
25599 int ecode2 = 0 ;
25600 PyObject * obj0 = 0 ;
25601 PyObject * obj1 = 0 ;
25602 char * kwnames[] = {
25603 (char *) "self",(char *) "ischange", NULL
25604 };
25605
25606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25608 if (!SWIG_IsOK(res1)) {
25609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25610 }
25611 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25612 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25613 if (!SWIG_IsOK(ecode2)) {
25614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25615 }
25616 arg2 = static_cast< bool >(val2);
25617 {
25618 PyThreadState* __tstate = wxPyBeginAllowThreads();
25619 (arg1)->SetWindowChange(arg2);
25620 wxPyEndAllowThreads(__tstate);
25621 if (PyErr_Occurred()) SWIG_fail;
25622 }
25623 resultobj = SWIG_Py_Void();
25624 return resultobj;
25625 fail:
25626 return NULL;
25627 }
25628
25629
25630 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25631 PyObject *resultobj = 0;
25632 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25633 bool result;
25634 void *argp1 = 0 ;
25635 int res1 = 0 ;
25636 PyObject *swig_obj[1] ;
25637
25638 if (!args) SWIG_fail;
25639 swig_obj[0] = args;
25640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25641 if (!SWIG_IsOK(res1)) {
25642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25643 }
25644 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25645 {
25646 PyThreadState* __tstate = wxPyBeginAllowThreads();
25647 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25648 wxPyEndAllowThreads(__tstate);
25649 if (PyErr_Occurred()) SWIG_fail;
25650 }
25651 {
25652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25653 }
25654 return resultobj;
25655 fail:
25656 return NULL;
25657 }
25658
25659
25660 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25661 PyObject *resultobj = 0;
25662 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25663 bool arg2 ;
25664 void *argp1 = 0 ;
25665 int res1 = 0 ;
25666 bool val2 ;
25667 int ecode2 = 0 ;
25668 PyObject * obj0 = 0 ;
25669 PyObject * obj1 = 0 ;
25670 char * kwnames[] = {
25671 (char *) "self",(char *) "bIs", NULL
25672 };
25673
25674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25676 if (!SWIG_IsOK(res1)) {
25677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25678 }
25679 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25680 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25681 if (!SWIG_IsOK(ecode2)) {
25682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25683 }
25684 arg2 = static_cast< bool >(val2);
25685 {
25686 PyThreadState* __tstate = wxPyBeginAllowThreads();
25687 (arg1)->SetFromTab(arg2);
25688 wxPyEndAllowThreads(__tstate);
25689 if (PyErr_Occurred()) SWIG_fail;
25690 }
25691 resultobj = SWIG_Py_Void();
25692 return resultobj;
25693 fail:
25694 return NULL;
25695 }
25696
25697
25698 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25699 PyObject *resultobj = 0;
25700 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25701 long arg2 ;
25702 void *argp1 = 0 ;
25703 int res1 = 0 ;
25704 long val2 ;
25705 int ecode2 = 0 ;
25706 PyObject * obj0 = 0 ;
25707 PyObject * obj1 = 0 ;
25708 char * kwnames[] = {
25709 (char *) "self",(char *) "flags", NULL
25710 };
25711
25712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25714 if (!SWIG_IsOK(res1)) {
25715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25716 }
25717 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25718 ecode2 = SWIG_AsVal_long(obj1, &val2);
25719 if (!SWIG_IsOK(ecode2)) {
25720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25721 }
25722 arg2 = static_cast< long >(val2);
25723 {
25724 PyThreadState* __tstate = wxPyBeginAllowThreads();
25725 (arg1)->SetFlags(arg2);
25726 wxPyEndAllowThreads(__tstate);
25727 if (PyErr_Occurred()) SWIG_fail;
25728 }
25729 resultobj = SWIG_Py_Void();
25730 return resultobj;
25731 fail:
25732 return NULL;
25733 }
25734
25735
25736 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25737 PyObject *resultobj = 0;
25738 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25739 wxWindow *result = 0 ;
25740 void *argp1 = 0 ;
25741 int res1 = 0 ;
25742 PyObject *swig_obj[1] ;
25743
25744 if (!args) SWIG_fail;
25745 swig_obj[0] = args;
25746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25747 if (!SWIG_IsOK(res1)) {
25748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25749 }
25750 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25751 {
25752 PyThreadState* __tstate = wxPyBeginAllowThreads();
25753 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25754 wxPyEndAllowThreads(__tstate);
25755 if (PyErr_Occurred()) SWIG_fail;
25756 }
25757 {
25758 resultobj = wxPyMake_wxObject(result, (bool)0);
25759 }
25760 return resultobj;
25761 fail:
25762 return NULL;
25763 }
25764
25765
25766 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25767 PyObject *resultobj = 0;
25768 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25769 wxWindow *arg2 = (wxWindow *) 0 ;
25770 void *argp1 = 0 ;
25771 int res1 = 0 ;
25772 void *argp2 = 0 ;
25773 int res2 = 0 ;
25774 PyObject * obj0 = 0 ;
25775 PyObject * obj1 = 0 ;
25776 char * kwnames[] = {
25777 (char *) "self",(char *) "win", NULL
25778 };
25779
25780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25782 if (!SWIG_IsOK(res1)) {
25783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25784 }
25785 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25786 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25787 if (!SWIG_IsOK(res2)) {
25788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25789 }
25790 arg2 = reinterpret_cast< wxWindow * >(argp2);
25791 {
25792 PyThreadState* __tstate = wxPyBeginAllowThreads();
25793 (arg1)->SetCurrentFocus(arg2);
25794 wxPyEndAllowThreads(__tstate);
25795 if (PyErr_Occurred()) SWIG_fail;
25796 }
25797 resultobj = SWIG_Py_Void();
25798 return resultobj;
25799 fail:
25800 return NULL;
25801 }
25802
25803
25804 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25805 PyObject *obj;
25806 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25807 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25808 return SWIG_Py_Void();
25809 }
25810
25811 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25812 return SWIG_Python_InitShadowInstance(args);
25813 }
25814
25815 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25816 PyObject *resultobj = 0;
25817 wxWindow *arg1 = (wxWindow *) NULL ;
25818 wxWindowCreateEvent *result = 0 ;
25819 void *argp1 = 0 ;
25820 int res1 = 0 ;
25821 PyObject * obj0 = 0 ;
25822 char * kwnames[] = {
25823 (char *) "win", NULL
25824 };
25825
25826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25827 if (obj0) {
25828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25829 if (!SWIG_IsOK(res1)) {
25830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25831 }
25832 arg1 = reinterpret_cast< wxWindow * >(argp1);
25833 }
25834 {
25835 PyThreadState* __tstate = wxPyBeginAllowThreads();
25836 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25837 wxPyEndAllowThreads(__tstate);
25838 if (PyErr_Occurred()) SWIG_fail;
25839 }
25840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25841 return resultobj;
25842 fail:
25843 return NULL;
25844 }
25845
25846
25847 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25848 PyObject *resultobj = 0;
25849 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25850 wxWindow *result = 0 ;
25851 void *argp1 = 0 ;
25852 int res1 = 0 ;
25853 PyObject *swig_obj[1] ;
25854
25855 if (!args) SWIG_fail;
25856 swig_obj[0] = args;
25857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25858 if (!SWIG_IsOK(res1)) {
25859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25860 }
25861 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25862 {
25863 PyThreadState* __tstate = wxPyBeginAllowThreads();
25864 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25865 wxPyEndAllowThreads(__tstate);
25866 if (PyErr_Occurred()) SWIG_fail;
25867 }
25868 {
25869 resultobj = wxPyMake_wxObject(result, (bool)0);
25870 }
25871 return resultobj;
25872 fail:
25873 return NULL;
25874 }
25875
25876
25877 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25878 PyObject *obj;
25879 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25880 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25881 return SWIG_Py_Void();
25882 }
25883
25884 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25885 return SWIG_Python_InitShadowInstance(args);
25886 }
25887
25888 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25889 PyObject *resultobj = 0;
25890 wxWindow *arg1 = (wxWindow *) NULL ;
25891 wxWindowDestroyEvent *result = 0 ;
25892 void *argp1 = 0 ;
25893 int res1 = 0 ;
25894 PyObject * obj0 = 0 ;
25895 char * kwnames[] = {
25896 (char *) "win", NULL
25897 };
25898
25899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
25900 if (obj0) {
25901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25902 if (!SWIG_IsOK(res1)) {
25903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25904 }
25905 arg1 = reinterpret_cast< wxWindow * >(argp1);
25906 }
25907 {
25908 PyThreadState* __tstate = wxPyBeginAllowThreads();
25909 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
25910 wxPyEndAllowThreads(__tstate);
25911 if (PyErr_Occurred()) SWIG_fail;
25912 }
25913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
25914 return resultobj;
25915 fail:
25916 return NULL;
25917 }
25918
25919
25920 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25921 PyObject *resultobj = 0;
25922 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
25923 wxWindow *result = 0 ;
25924 void *argp1 = 0 ;
25925 int res1 = 0 ;
25926 PyObject *swig_obj[1] ;
25927
25928 if (!args) SWIG_fail;
25929 swig_obj[0] = args;
25930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
25931 if (!SWIG_IsOK(res1)) {
25932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
25933 }
25934 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
25935 {
25936 PyThreadState* __tstate = wxPyBeginAllowThreads();
25937 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
25938 wxPyEndAllowThreads(__tstate);
25939 if (PyErr_Occurred()) SWIG_fail;
25940 }
25941 {
25942 resultobj = wxPyMake_wxObject(result, (bool)0);
25943 }
25944 return resultobj;
25945 fail:
25946 return NULL;
25947 }
25948
25949
25950 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25951 PyObject *obj;
25952 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25953 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
25954 return SWIG_Py_Void();
25955 }
25956
25957 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25958 return SWIG_Python_InitShadowInstance(args);
25959 }
25960
25961 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25962 PyObject *resultobj = 0;
25963 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
25964 int arg2 = (int) 0 ;
25965 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25966 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25967 wxContextMenuEvent *result = 0 ;
25968 int val1 ;
25969 int ecode1 = 0 ;
25970 int val2 ;
25971 int ecode2 = 0 ;
25972 wxPoint temp3 ;
25973 PyObject * obj0 = 0 ;
25974 PyObject * obj1 = 0 ;
25975 PyObject * obj2 = 0 ;
25976 char * kwnames[] = {
25977 (char *) "type",(char *) "winid",(char *) "pt", NULL
25978 };
25979
25980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25981 if (obj0) {
25982 ecode1 = SWIG_AsVal_int(obj0, &val1);
25983 if (!SWIG_IsOK(ecode1)) {
25984 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
25985 }
25986 arg1 = static_cast< wxEventType >(val1);
25987 }
25988 if (obj1) {
25989 ecode2 = SWIG_AsVal_int(obj1, &val2);
25990 if (!SWIG_IsOK(ecode2)) {
25991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
25992 }
25993 arg2 = static_cast< int >(val2);
25994 }
25995 if (obj2) {
25996 {
25997 arg3 = &temp3;
25998 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25999 }
26000 }
26001 {
26002 PyThreadState* __tstate = wxPyBeginAllowThreads();
26003 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26004 wxPyEndAllowThreads(__tstate);
26005 if (PyErr_Occurred()) SWIG_fail;
26006 }
26007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26008 return resultobj;
26009 fail:
26010 return NULL;
26011 }
26012
26013
26014 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26015 PyObject *resultobj = 0;
26016 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26017 wxPoint *result = 0 ;
26018 void *argp1 = 0 ;
26019 int res1 = 0 ;
26020 PyObject *swig_obj[1] ;
26021
26022 if (!args) SWIG_fail;
26023 swig_obj[0] = args;
26024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26025 if (!SWIG_IsOK(res1)) {
26026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26027 }
26028 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26029 {
26030 PyThreadState* __tstate = wxPyBeginAllowThreads();
26031 {
26032 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26033 result = (wxPoint *) &_result_ref;
26034 }
26035 wxPyEndAllowThreads(__tstate);
26036 if (PyErr_Occurred()) SWIG_fail;
26037 }
26038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26039 return resultobj;
26040 fail:
26041 return NULL;
26042 }
26043
26044
26045 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26046 PyObject *resultobj = 0;
26047 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26048 wxPoint *arg2 = 0 ;
26049 void *argp1 = 0 ;
26050 int res1 = 0 ;
26051 wxPoint temp2 ;
26052 PyObject * obj0 = 0 ;
26053 PyObject * obj1 = 0 ;
26054 char * kwnames[] = {
26055 (char *) "self",(char *) "pos", NULL
26056 };
26057
26058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26060 if (!SWIG_IsOK(res1)) {
26061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26062 }
26063 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26064 {
26065 arg2 = &temp2;
26066 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26067 }
26068 {
26069 PyThreadState* __tstate = wxPyBeginAllowThreads();
26070 (arg1)->SetPosition((wxPoint const &)*arg2);
26071 wxPyEndAllowThreads(__tstate);
26072 if (PyErr_Occurred()) SWIG_fail;
26073 }
26074 resultobj = SWIG_Py_Void();
26075 return resultobj;
26076 fail:
26077 return NULL;
26078 }
26079
26080
26081 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26082 PyObject *obj;
26083 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26084 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26085 return SWIG_Py_Void();
26086 }
26087
26088 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26089 return SWIG_Python_InitShadowInstance(args);
26090 }
26091
26092 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26093 PyObject *resultobj = 0;
26094 wxIdleEvent *result = 0 ;
26095
26096 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26097 {
26098 PyThreadState* __tstate = wxPyBeginAllowThreads();
26099 result = (wxIdleEvent *)new wxIdleEvent();
26100 wxPyEndAllowThreads(__tstate);
26101 if (PyErr_Occurred()) SWIG_fail;
26102 }
26103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26104 return resultobj;
26105 fail:
26106 return NULL;
26107 }
26108
26109
26110 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26111 PyObject *resultobj = 0;
26112 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26113 bool arg2 = (bool) true ;
26114 void *argp1 = 0 ;
26115 int res1 = 0 ;
26116 bool val2 ;
26117 int ecode2 = 0 ;
26118 PyObject * obj0 = 0 ;
26119 PyObject * obj1 = 0 ;
26120 char * kwnames[] = {
26121 (char *) "self",(char *) "needMore", NULL
26122 };
26123
26124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26126 if (!SWIG_IsOK(res1)) {
26127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26128 }
26129 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26130 if (obj1) {
26131 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26132 if (!SWIG_IsOK(ecode2)) {
26133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26134 }
26135 arg2 = static_cast< bool >(val2);
26136 }
26137 {
26138 PyThreadState* __tstate = wxPyBeginAllowThreads();
26139 (arg1)->RequestMore(arg2);
26140 wxPyEndAllowThreads(__tstate);
26141 if (PyErr_Occurred()) SWIG_fail;
26142 }
26143 resultobj = SWIG_Py_Void();
26144 return resultobj;
26145 fail:
26146 return NULL;
26147 }
26148
26149
26150 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26151 PyObject *resultobj = 0;
26152 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26153 bool result;
26154 void *argp1 = 0 ;
26155 int res1 = 0 ;
26156 PyObject *swig_obj[1] ;
26157
26158 if (!args) SWIG_fail;
26159 swig_obj[0] = args;
26160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26161 if (!SWIG_IsOK(res1)) {
26162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26163 }
26164 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26165 {
26166 PyThreadState* __tstate = wxPyBeginAllowThreads();
26167 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26168 wxPyEndAllowThreads(__tstate);
26169 if (PyErr_Occurred()) SWIG_fail;
26170 }
26171 {
26172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26173 }
26174 return resultobj;
26175 fail:
26176 return NULL;
26177 }
26178
26179
26180 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26181 PyObject *resultobj = 0;
26182 wxIdleMode arg1 ;
26183 int val1 ;
26184 int ecode1 = 0 ;
26185 PyObject * obj0 = 0 ;
26186 char * kwnames[] = {
26187 (char *) "mode", NULL
26188 };
26189
26190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26191 ecode1 = SWIG_AsVal_int(obj0, &val1);
26192 if (!SWIG_IsOK(ecode1)) {
26193 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26194 }
26195 arg1 = static_cast< wxIdleMode >(val1);
26196 {
26197 PyThreadState* __tstate = wxPyBeginAllowThreads();
26198 wxIdleEvent::SetMode(arg1);
26199 wxPyEndAllowThreads(__tstate);
26200 if (PyErr_Occurred()) SWIG_fail;
26201 }
26202 resultobj = SWIG_Py_Void();
26203 return resultobj;
26204 fail:
26205 return NULL;
26206 }
26207
26208
26209 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26210 PyObject *resultobj = 0;
26211 wxIdleMode result;
26212
26213 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26214 {
26215 PyThreadState* __tstate = wxPyBeginAllowThreads();
26216 result = (wxIdleMode)wxIdleEvent::GetMode();
26217 wxPyEndAllowThreads(__tstate);
26218 if (PyErr_Occurred()) SWIG_fail;
26219 }
26220 resultobj = SWIG_From_int(static_cast< int >(result));
26221 return resultobj;
26222 fail:
26223 return NULL;
26224 }
26225
26226
26227 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26228 PyObject *resultobj = 0;
26229 wxWindow *arg1 = (wxWindow *) 0 ;
26230 bool result;
26231 void *argp1 = 0 ;
26232 int res1 = 0 ;
26233 PyObject * obj0 = 0 ;
26234 char * kwnames[] = {
26235 (char *) "win", NULL
26236 };
26237
26238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26240 if (!SWIG_IsOK(res1)) {
26241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26242 }
26243 arg1 = reinterpret_cast< wxWindow * >(argp1);
26244 {
26245 PyThreadState* __tstate = wxPyBeginAllowThreads();
26246 result = (bool)wxIdleEvent::CanSend(arg1);
26247 wxPyEndAllowThreads(__tstate);
26248 if (PyErr_Occurred()) SWIG_fail;
26249 }
26250 {
26251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26252 }
26253 return resultobj;
26254 fail:
26255 return NULL;
26256 }
26257
26258
26259 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26260 PyObject *obj;
26261 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26262 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26263 return SWIG_Py_Void();
26264 }
26265
26266 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26267 return SWIG_Python_InitShadowInstance(args);
26268 }
26269
26270 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26271 PyObject *resultobj = 0;
26272 int arg1 = (int) 0 ;
26273 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26274 wxPyEvent *result = 0 ;
26275 int val1 ;
26276 int ecode1 = 0 ;
26277 int val2 ;
26278 int ecode2 = 0 ;
26279 PyObject * obj0 = 0 ;
26280 PyObject * obj1 = 0 ;
26281 char * kwnames[] = {
26282 (char *) "winid",(char *) "eventType", NULL
26283 };
26284
26285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26286 if (obj0) {
26287 ecode1 = SWIG_AsVal_int(obj0, &val1);
26288 if (!SWIG_IsOK(ecode1)) {
26289 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26290 }
26291 arg1 = static_cast< int >(val1);
26292 }
26293 if (obj1) {
26294 ecode2 = SWIG_AsVal_int(obj1, &val2);
26295 if (!SWIG_IsOK(ecode2)) {
26296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26297 }
26298 arg2 = static_cast< wxEventType >(val2);
26299 }
26300 {
26301 PyThreadState* __tstate = wxPyBeginAllowThreads();
26302 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26303 wxPyEndAllowThreads(__tstate);
26304 if (PyErr_Occurred()) SWIG_fail;
26305 }
26306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26307 return resultobj;
26308 fail:
26309 return NULL;
26310 }
26311
26312
26313 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26314 PyObject *resultobj = 0;
26315 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26316 void *argp1 = 0 ;
26317 int res1 = 0 ;
26318 PyObject *swig_obj[1] ;
26319
26320 if (!args) SWIG_fail;
26321 swig_obj[0] = args;
26322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26323 if (!SWIG_IsOK(res1)) {
26324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26325 }
26326 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26327 {
26328 PyThreadState* __tstate = wxPyBeginAllowThreads();
26329 delete arg1;
26330
26331 wxPyEndAllowThreads(__tstate);
26332 if (PyErr_Occurred()) SWIG_fail;
26333 }
26334 resultobj = SWIG_Py_Void();
26335 return resultobj;
26336 fail:
26337 return NULL;
26338 }
26339
26340
26341 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26342 PyObject *resultobj = 0;
26343 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26344 PyObject *arg2 = (PyObject *) 0 ;
26345 void *argp1 = 0 ;
26346 int res1 = 0 ;
26347 PyObject * obj0 = 0 ;
26348 PyObject * obj1 = 0 ;
26349 char * kwnames[] = {
26350 (char *) "self",(char *) "self", NULL
26351 };
26352
26353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26355 if (!SWIG_IsOK(res1)) {
26356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26357 }
26358 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26359 arg2 = obj1;
26360 {
26361 PyThreadState* __tstate = wxPyBeginAllowThreads();
26362 (arg1)->SetSelf(arg2);
26363 wxPyEndAllowThreads(__tstate);
26364 if (PyErr_Occurred()) SWIG_fail;
26365 }
26366 resultobj = SWIG_Py_Void();
26367 return resultobj;
26368 fail:
26369 return NULL;
26370 }
26371
26372
26373 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26374 PyObject *resultobj = 0;
26375 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26376 PyObject *result = 0 ;
26377 void *argp1 = 0 ;
26378 int res1 = 0 ;
26379 PyObject *swig_obj[1] ;
26380
26381 if (!args) SWIG_fail;
26382 swig_obj[0] = args;
26383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26384 if (!SWIG_IsOK(res1)) {
26385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26386 }
26387 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26388 {
26389 PyThreadState* __tstate = wxPyBeginAllowThreads();
26390 result = (PyObject *)(arg1)->GetSelf();
26391 wxPyEndAllowThreads(__tstate);
26392 if (PyErr_Occurred()) SWIG_fail;
26393 }
26394 resultobj = result;
26395 return resultobj;
26396 fail:
26397 return NULL;
26398 }
26399
26400
26401 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26402 PyObject *obj;
26403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26404 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26405 return SWIG_Py_Void();
26406 }
26407
26408 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26409 return SWIG_Python_InitShadowInstance(args);
26410 }
26411
26412 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26413 PyObject *resultobj = 0;
26414 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26415 int arg2 = (int) 0 ;
26416 wxPyCommandEvent *result = 0 ;
26417 int val1 ;
26418 int ecode1 = 0 ;
26419 int val2 ;
26420 int ecode2 = 0 ;
26421 PyObject * obj0 = 0 ;
26422 PyObject * obj1 = 0 ;
26423 char * kwnames[] = {
26424 (char *) "eventType",(char *) "id", NULL
26425 };
26426
26427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26428 if (obj0) {
26429 ecode1 = SWIG_AsVal_int(obj0, &val1);
26430 if (!SWIG_IsOK(ecode1)) {
26431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26432 }
26433 arg1 = static_cast< wxEventType >(val1);
26434 }
26435 if (obj1) {
26436 ecode2 = SWIG_AsVal_int(obj1, &val2);
26437 if (!SWIG_IsOK(ecode2)) {
26438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26439 }
26440 arg2 = static_cast< int >(val2);
26441 }
26442 {
26443 PyThreadState* __tstate = wxPyBeginAllowThreads();
26444 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26445 wxPyEndAllowThreads(__tstate);
26446 if (PyErr_Occurred()) SWIG_fail;
26447 }
26448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26449 return resultobj;
26450 fail:
26451 return NULL;
26452 }
26453
26454
26455 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26456 PyObject *resultobj = 0;
26457 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26458 void *argp1 = 0 ;
26459 int res1 = 0 ;
26460 PyObject *swig_obj[1] ;
26461
26462 if (!args) SWIG_fail;
26463 swig_obj[0] = args;
26464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26465 if (!SWIG_IsOK(res1)) {
26466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26467 }
26468 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26469 {
26470 PyThreadState* __tstate = wxPyBeginAllowThreads();
26471 delete arg1;
26472
26473 wxPyEndAllowThreads(__tstate);
26474 if (PyErr_Occurred()) SWIG_fail;
26475 }
26476 resultobj = SWIG_Py_Void();
26477 return resultobj;
26478 fail:
26479 return NULL;
26480 }
26481
26482
26483 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26484 PyObject *resultobj = 0;
26485 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26486 PyObject *arg2 = (PyObject *) 0 ;
26487 void *argp1 = 0 ;
26488 int res1 = 0 ;
26489 PyObject * obj0 = 0 ;
26490 PyObject * obj1 = 0 ;
26491 char * kwnames[] = {
26492 (char *) "self",(char *) "self", NULL
26493 };
26494
26495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26497 if (!SWIG_IsOK(res1)) {
26498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26499 }
26500 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26501 arg2 = obj1;
26502 {
26503 PyThreadState* __tstate = wxPyBeginAllowThreads();
26504 (arg1)->SetSelf(arg2);
26505 wxPyEndAllowThreads(__tstate);
26506 if (PyErr_Occurred()) SWIG_fail;
26507 }
26508 resultobj = SWIG_Py_Void();
26509 return resultobj;
26510 fail:
26511 return NULL;
26512 }
26513
26514
26515 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26516 PyObject *resultobj = 0;
26517 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26518 PyObject *result = 0 ;
26519 void *argp1 = 0 ;
26520 int res1 = 0 ;
26521 PyObject *swig_obj[1] ;
26522
26523 if (!args) SWIG_fail;
26524 swig_obj[0] = args;
26525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26526 if (!SWIG_IsOK(res1)) {
26527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26528 }
26529 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26530 {
26531 PyThreadState* __tstate = wxPyBeginAllowThreads();
26532 result = (PyObject *)(arg1)->GetSelf();
26533 wxPyEndAllowThreads(__tstate);
26534 if (PyErr_Occurred()) SWIG_fail;
26535 }
26536 resultobj = result;
26537 return resultobj;
26538 fail:
26539 return NULL;
26540 }
26541
26542
26543 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26544 PyObject *obj;
26545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26546 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26547 return SWIG_Py_Void();
26548 }
26549
26550 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26551 return SWIG_Python_InitShadowInstance(args);
26552 }
26553
26554 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26555 PyObject *resultobj = 0;
26556 wxWindow *arg1 = (wxWindow *) 0 ;
26557 wxDateTime *arg2 = 0 ;
26558 wxEventType arg3 ;
26559 wxDateEvent *result = 0 ;
26560 void *argp1 = 0 ;
26561 int res1 = 0 ;
26562 void *argp2 = 0 ;
26563 int res2 = 0 ;
26564 int val3 ;
26565 int ecode3 = 0 ;
26566 PyObject * obj0 = 0 ;
26567 PyObject * obj1 = 0 ;
26568 PyObject * obj2 = 0 ;
26569 char * kwnames[] = {
26570 (char *) "win",(char *) "dt",(char *) "type", NULL
26571 };
26572
26573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26575 if (!SWIG_IsOK(res1)) {
26576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26577 }
26578 arg1 = reinterpret_cast< wxWindow * >(argp1);
26579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26580 if (!SWIG_IsOK(res2)) {
26581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26582 }
26583 if (!argp2) {
26584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26585 }
26586 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26587 ecode3 = SWIG_AsVal_int(obj2, &val3);
26588 if (!SWIG_IsOK(ecode3)) {
26589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26590 }
26591 arg3 = static_cast< wxEventType >(val3);
26592 {
26593 PyThreadState* __tstate = wxPyBeginAllowThreads();
26594 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26595 wxPyEndAllowThreads(__tstate);
26596 if (PyErr_Occurred()) SWIG_fail;
26597 }
26598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26599 return resultobj;
26600 fail:
26601 return NULL;
26602 }
26603
26604
26605 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26606 PyObject *resultobj = 0;
26607 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26608 wxDateTime *result = 0 ;
26609 void *argp1 = 0 ;
26610 int res1 = 0 ;
26611 PyObject *swig_obj[1] ;
26612
26613 if (!args) SWIG_fail;
26614 swig_obj[0] = args;
26615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26616 if (!SWIG_IsOK(res1)) {
26617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26618 }
26619 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26620 {
26621 PyThreadState* __tstate = wxPyBeginAllowThreads();
26622 {
26623 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26624 result = (wxDateTime *) &_result_ref;
26625 }
26626 wxPyEndAllowThreads(__tstate);
26627 if (PyErr_Occurred()) SWIG_fail;
26628 }
26629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26630 return resultobj;
26631 fail:
26632 return NULL;
26633 }
26634
26635
26636 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26637 PyObject *resultobj = 0;
26638 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26639 wxDateTime *arg2 = 0 ;
26640 void *argp1 = 0 ;
26641 int res1 = 0 ;
26642 void *argp2 = 0 ;
26643 int res2 = 0 ;
26644 PyObject * obj0 = 0 ;
26645 PyObject * obj1 = 0 ;
26646 char * kwnames[] = {
26647 (char *) "self",(char *) "date", NULL
26648 };
26649
26650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26652 if (!SWIG_IsOK(res1)) {
26653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26654 }
26655 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26656 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26657 if (!SWIG_IsOK(res2)) {
26658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26659 }
26660 if (!argp2) {
26661 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26662 }
26663 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26664 {
26665 PyThreadState* __tstate = wxPyBeginAllowThreads();
26666 (arg1)->SetDate((wxDateTime const &)*arg2);
26667 wxPyEndAllowThreads(__tstate);
26668 if (PyErr_Occurred()) SWIG_fail;
26669 }
26670 resultobj = SWIG_Py_Void();
26671 return resultobj;
26672 fail:
26673 return NULL;
26674 }
26675
26676
26677 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26678 PyObject *obj;
26679 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26680 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26681 return SWIG_Py_Void();
26682 }
26683
26684 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26685 return SWIG_Python_InitShadowInstance(args);
26686 }
26687
26688 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26689 PyObject *resultobj = 0;
26690 wxPyApp *result = 0 ;
26691
26692 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26693 {
26694 PyThreadState* __tstate = wxPyBeginAllowThreads();
26695 result = (wxPyApp *)new_wxPyApp();
26696 wxPyEndAllowThreads(__tstate);
26697 if (PyErr_Occurred()) SWIG_fail;
26698 }
26699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26700 return resultobj;
26701 fail:
26702 return NULL;
26703 }
26704
26705
26706 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26707 PyObject *resultobj = 0;
26708 wxPyApp *arg1 = (wxPyApp *) 0 ;
26709 void *argp1 = 0 ;
26710 int res1 = 0 ;
26711 PyObject *swig_obj[1] ;
26712
26713 if (!args) SWIG_fail;
26714 swig_obj[0] = args;
26715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26716 if (!SWIG_IsOK(res1)) {
26717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26718 }
26719 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26720 {
26721 PyThreadState* __tstate = wxPyBeginAllowThreads();
26722 delete arg1;
26723
26724 wxPyEndAllowThreads(__tstate);
26725 if (PyErr_Occurred()) SWIG_fail;
26726 }
26727 resultobj = SWIG_Py_Void();
26728 return resultobj;
26729 fail:
26730 return NULL;
26731 }
26732
26733
26734 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26735 PyObject *resultobj = 0;
26736 wxPyApp *arg1 = (wxPyApp *) 0 ;
26737 PyObject *arg2 = (PyObject *) 0 ;
26738 PyObject *arg3 = (PyObject *) 0 ;
26739 bool arg4 ;
26740 void *argp1 = 0 ;
26741 int res1 = 0 ;
26742 bool val4 ;
26743 int ecode4 = 0 ;
26744 PyObject * obj0 = 0 ;
26745 PyObject * obj1 = 0 ;
26746 PyObject * obj2 = 0 ;
26747 PyObject * obj3 = 0 ;
26748 char * kwnames[] = {
26749 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26750 };
26751
26752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26754 if (!SWIG_IsOK(res1)) {
26755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26756 }
26757 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26758 arg2 = obj1;
26759 arg3 = obj2;
26760 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26761 if (!SWIG_IsOK(ecode4)) {
26762 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26763 }
26764 arg4 = static_cast< bool >(val4);
26765 {
26766 PyThreadState* __tstate = wxPyBeginAllowThreads();
26767 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26768 wxPyEndAllowThreads(__tstate);
26769 if (PyErr_Occurred()) SWIG_fail;
26770 }
26771 resultobj = SWIG_Py_Void();
26772 return resultobj;
26773 fail:
26774 return NULL;
26775 }
26776
26777
26778 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26779 PyObject *resultobj = 0;
26780 wxPyApp *arg1 = (wxPyApp *) 0 ;
26781 wxString result;
26782 void *argp1 = 0 ;
26783 int res1 = 0 ;
26784 PyObject *swig_obj[1] ;
26785
26786 if (!args) SWIG_fail;
26787 swig_obj[0] = args;
26788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26789 if (!SWIG_IsOK(res1)) {
26790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26791 }
26792 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26793 {
26794 PyThreadState* __tstate = wxPyBeginAllowThreads();
26795 result = ((wxPyApp const *)arg1)->GetAppName();
26796 wxPyEndAllowThreads(__tstate);
26797 if (PyErr_Occurred()) SWIG_fail;
26798 }
26799 {
26800 #if wxUSE_UNICODE
26801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26802 #else
26803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26804 #endif
26805 }
26806 return resultobj;
26807 fail:
26808 return NULL;
26809 }
26810
26811
26812 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26813 PyObject *resultobj = 0;
26814 wxPyApp *arg1 = (wxPyApp *) 0 ;
26815 wxString *arg2 = 0 ;
26816 void *argp1 = 0 ;
26817 int res1 = 0 ;
26818 bool temp2 = false ;
26819 PyObject * obj0 = 0 ;
26820 PyObject * obj1 = 0 ;
26821 char * kwnames[] = {
26822 (char *) "self",(char *) "name", NULL
26823 };
26824
26825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26827 if (!SWIG_IsOK(res1)) {
26828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26829 }
26830 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26831 {
26832 arg2 = wxString_in_helper(obj1);
26833 if (arg2 == NULL) SWIG_fail;
26834 temp2 = true;
26835 }
26836 {
26837 PyThreadState* __tstate = wxPyBeginAllowThreads();
26838 (arg1)->SetAppName((wxString const &)*arg2);
26839 wxPyEndAllowThreads(__tstate);
26840 if (PyErr_Occurred()) SWIG_fail;
26841 }
26842 resultobj = SWIG_Py_Void();
26843 {
26844 if (temp2)
26845 delete arg2;
26846 }
26847 return resultobj;
26848 fail:
26849 {
26850 if (temp2)
26851 delete arg2;
26852 }
26853 return NULL;
26854 }
26855
26856
26857 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26858 PyObject *resultobj = 0;
26859 wxPyApp *arg1 = (wxPyApp *) 0 ;
26860 wxString result;
26861 void *argp1 = 0 ;
26862 int res1 = 0 ;
26863 PyObject *swig_obj[1] ;
26864
26865 if (!args) SWIG_fail;
26866 swig_obj[0] = args;
26867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26868 if (!SWIG_IsOK(res1)) {
26869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26870 }
26871 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26872 {
26873 PyThreadState* __tstate = wxPyBeginAllowThreads();
26874 result = ((wxPyApp const *)arg1)->GetClassName();
26875 wxPyEndAllowThreads(__tstate);
26876 if (PyErr_Occurred()) SWIG_fail;
26877 }
26878 {
26879 #if wxUSE_UNICODE
26880 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26881 #else
26882 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26883 #endif
26884 }
26885 return resultobj;
26886 fail:
26887 return NULL;
26888 }
26889
26890
26891 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26892 PyObject *resultobj = 0;
26893 wxPyApp *arg1 = (wxPyApp *) 0 ;
26894 wxString *arg2 = 0 ;
26895 void *argp1 = 0 ;
26896 int res1 = 0 ;
26897 bool temp2 = false ;
26898 PyObject * obj0 = 0 ;
26899 PyObject * obj1 = 0 ;
26900 char * kwnames[] = {
26901 (char *) "self",(char *) "name", NULL
26902 };
26903
26904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
26905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26906 if (!SWIG_IsOK(res1)) {
26907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26908 }
26909 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26910 {
26911 arg2 = wxString_in_helper(obj1);
26912 if (arg2 == NULL) SWIG_fail;
26913 temp2 = true;
26914 }
26915 {
26916 PyThreadState* __tstate = wxPyBeginAllowThreads();
26917 (arg1)->SetClassName((wxString const &)*arg2);
26918 wxPyEndAllowThreads(__tstate);
26919 if (PyErr_Occurred()) SWIG_fail;
26920 }
26921 resultobj = SWIG_Py_Void();
26922 {
26923 if (temp2)
26924 delete arg2;
26925 }
26926 return resultobj;
26927 fail:
26928 {
26929 if (temp2)
26930 delete arg2;
26931 }
26932 return NULL;
26933 }
26934
26935
26936 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26937 PyObject *resultobj = 0;
26938 wxPyApp *arg1 = (wxPyApp *) 0 ;
26939 wxString *result = 0 ;
26940 void *argp1 = 0 ;
26941 int res1 = 0 ;
26942 PyObject *swig_obj[1] ;
26943
26944 if (!args) SWIG_fail;
26945 swig_obj[0] = args;
26946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26947 if (!SWIG_IsOK(res1)) {
26948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26949 }
26950 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26951 {
26952 PyThreadState* __tstate = wxPyBeginAllowThreads();
26953 {
26954 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
26955 result = (wxString *) &_result_ref;
26956 }
26957 wxPyEndAllowThreads(__tstate);
26958 if (PyErr_Occurred()) SWIG_fail;
26959 }
26960 {
26961 #if wxUSE_UNICODE
26962 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
26963 #else
26964 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
26965 #endif
26966 }
26967 return resultobj;
26968 fail:
26969 return NULL;
26970 }
26971
26972
26973 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26974 PyObject *resultobj = 0;
26975 wxPyApp *arg1 = (wxPyApp *) 0 ;
26976 wxString *arg2 = 0 ;
26977 void *argp1 = 0 ;
26978 int res1 = 0 ;
26979 bool temp2 = false ;
26980 PyObject * obj0 = 0 ;
26981 PyObject * obj1 = 0 ;
26982 char * kwnames[] = {
26983 (char *) "self",(char *) "name", NULL
26984 };
26985
26986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
26987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26988 if (!SWIG_IsOK(res1)) {
26989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26990 }
26991 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26992 {
26993 arg2 = wxString_in_helper(obj1);
26994 if (arg2 == NULL) SWIG_fail;
26995 temp2 = true;
26996 }
26997 {
26998 PyThreadState* __tstate = wxPyBeginAllowThreads();
26999 (arg1)->SetVendorName((wxString const &)*arg2);
27000 wxPyEndAllowThreads(__tstate);
27001 if (PyErr_Occurred()) SWIG_fail;
27002 }
27003 resultobj = SWIG_Py_Void();
27004 {
27005 if (temp2)
27006 delete arg2;
27007 }
27008 return resultobj;
27009 fail:
27010 {
27011 if (temp2)
27012 delete arg2;
27013 }
27014 return NULL;
27015 }
27016
27017
27018 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27019 PyObject *resultobj = 0;
27020 wxPyApp *arg1 = (wxPyApp *) 0 ;
27021 wxAppTraits *result = 0 ;
27022 void *argp1 = 0 ;
27023 int res1 = 0 ;
27024 PyObject *swig_obj[1] ;
27025
27026 if (!args) SWIG_fail;
27027 swig_obj[0] = args;
27028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27029 if (!SWIG_IsOK(res1)) {
27030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27031 }
27032 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27033 {
27034 PyThreadState* __tstate = wxPyBeginAllowThreads();
27035 result = (wxAppTraits *)(arg1)->GetTraits();
27036 wxPyEndAllowThreads(__tstate);
27037 if (PyErr_Occurred()) SWIG_fail;
27038 }
27039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27040 return resultobj;
27041 fail:
27042 return NULL;
27043 }
27044
27045
27046 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27047 PyObject *resultobj = 0;
27048 wxPyApp *arg1 = (wxPyApp *) 0 ;
27049 void *argp1 = 0 ;
27050 int res1 = 0 ;
27051 PyObject *swig_obj[1] ;
27052
27053 if (!args) SWIG_fail;
27054 swig_obj[0] = args;
27055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27056 if (!SWIG_IsOK(res1)) {
27057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27058 }
27059 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27060 {
27061 PyThreadState* __tstate = wxPyBeginAllowThreads();
27062 (arg1)->ProcessPendingEvents();
27063 wxPyEndAllowThreads(__tstate);
27064 if (PyErr_Occurred()) SWIG_fail;
27065 }
27066 resultobj = SWIG_Py_Void();
27067 return resultobj;
27068 fail:
27069 return NULL;
27070 }
27071
27072
27073 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27074 PyObject *resultobj = 0;
27075 wxPyApp *arg1 = (wxPyApp *) 0 ;
27076 bool arg2 = (bool) false ;
27077 bool result;
27078 void *argp1 = 0 ;
27079 int res1 = 0 ;
27080 bool val2 ;
27081 int ecode2 = 0 ;
27082 PyObject * obj0 = 0 ;
27083 PyObject * obj1 = 0 ;
27084 char * kwnames[] = {
27085 (char *) "self",(char *) "onlyIfNeeded", NULL
27086 };
27087
27088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27090 if (!SWIG_IsOK(res1)) {
27091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27092 }
27093 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27094 if (obj1) {
27095 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27096 if (!SWIG_IsOK(ecode2)) {
27097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27098 }
27099 arg2 = static_cast< bool >(val2);
27100 }
27101 {
27102 PyThreadState* __tstate = wxPyBeginAllowThreads();
27103 result = (bool)(arg1)->Yield(arg2);
27104 wxPyEndAllowThreads(__tstate);
27105 if (PyErr_Occurred()) SWIG_fail;
27106 }
27107 {
27108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27109 }
27110 return resultobj;
27111 fail:
27112 return NULL;
27113 }
27114
27115
27116 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27117 PyObject *resultobj = 0;
27118 wxPyApp *arg1 = (wxPyApp *) 0 ;
27119 void *argp1 = 0 ;
27120 int res1 = 0 ;
27121 PyObject *swig_obj[1] ;
27122
27123 if (!args) SWIG_fail;
27124 swig_obj[0] = args;
27125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27126 if (!SWIG_IsOK(res1)) {
27127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27128 }
27129 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27130 {
27131 PyThreadState* __tstate = wxPyBeginAllowThreads();
27132 (arg1)->WakeUpIdle();
27133 wxPyEndAllowThreads(__tstate);
27134 if (PyErr_Occurred()) SWIG_fail;
27135 }
27136 resultobj = SWIG_Py_Void();
27137 return resultobj;
27138 fail:
27139 return NULL;
27140 }
27141
27142
27143 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27144 PyObject *resultobj = 0;
27145 bool result;
27146
27147 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27148 {
27149 PyThreadState* __tstate = wxPyBeginAllowThreads();
27150 result = (bool)wxPyApp::IsMainLoopRunning();
27151 wxPyEndAllowThreads(__tstate);
27152 if (PyErr_Occurred()) SWIG_fail;
27153 }
27154 {
27155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27156 }
27157 return resultobj;
27158 fail:
27159 return NULL;
27160 }
27161
27162
27163 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27164 PyObject *resultobj = 0;
27165 wxPyApp *arg1 = (wxPyApp *) 0 ;
27166 int result;
27167 void *argp1 = 0 ;
27168 int res1 = 0 ;
27169 PyObject *swig_obj[1] ;
27170
27171 if (!args) SWIG_fail;
27172 swig_obj[0] = args;
27173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27174 if (!SWIG_IsOK(res1)) {
27175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27176 }
27177 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27178 {
27179 PyThreadState* __tstate = wxPyBeginAllowThreads();
27180 result = (int)(arg1)->MainLoop();
27181 wxPyEndAllowThreads(__tstate);
27182 if (PyErr_Occurred()) SWIG_fail;
27183 }
27184 resultobj = SWIG_From_int(static_cast< int >(result));
27185 return resultobj;
27186 fail:
27187 return NULL;
27188 }
27189
27190
27191 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27192 PyObject *resultobj = 0;
27193 wxPyApp *arg1 = (wxPyApp *) 0 ;
27194 void *argp1 = 0 ;
27195 int res1 = 0 ;
27196 PyObject *swig_obj[1] ;
27197
27198 if (!args) SWIG_fail;
27199 swig_obj[0] = args;
27200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27201 if (!SWIG_IsOK(res1)) {
27202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27203 }
27204 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27205 {
27206 PyThreadState* __tstate = wxPyBeginAllowThreads();
27207 (arg1)->Exit();
27208 wxPyEndAllowThreads(__tstate);
27209 if (PyErr_Occurred()) SWIG_fail;
27210 }
27211 resultobj = SWIG_Py_Void();
27212 return resultobj;
27213 fail:
27214 return NULL;
27215 }
27216
27217
27218 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27219 PyObject *resultobj = 0;
27220 wxPyApp *arg1 = (wxPyApp *) 0 ;
27221 void *argp1 = 0 ;
27222 int res1 = 0 ;
27223 PyObject *swig_obj[1] ;
27224
27225 if (!args) SWIG_fail;
27226 swig_obj[0] = args;
27227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27228 if (!SWIG_IsOK(res1)) {
27229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27230 }
27231 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27232 {
27233 PyThreadState* __tstate = wxPyBeginAllowThreads();
27234 (arg1)->ExitMainLoop();
27235 wxPyEndAllowThreads(__tstate);
27236 if (PyErr_Occurred()) SWIG_fail;
27237 }
27238 resultobj = SWIG_Py_Void();
27239 return resultobj;
27240 fail:
27241 return NULL;
27242 }
27243
27244
27245 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27246 PyObject *resultobj = 0;
27247 wxPyApp *arg1 = (wxPyApp *) 0 ;
27248 bool result;
27249 void *argp1 = 0 ;
27250 int res1 = 0 ;
27251 PyObject *swig_obj[1] ;
27252
27253 if (!args) SWIG_fail;
27254 swig_obj[0] = args;
27255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27256 if (!SWIG_IsOK(res1)) {
27257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27258 }
27259 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27260 {
27261 PyThreadState* __tstate = wxPyBeginAllowThreads();
27262 result = (bool)(arg1)->Pending();
27263 wxPyEndAllowThreads(__tstate);
27264 if (PyErr_Occurred()) SWIG_fail;
27265 }
27266 {
27267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27268 }
27269 return resultobj;
27270 fail:
27271 return NULL;
27272 }
27273
27274
27275 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27276 PyObject *resultobj = 0;
27277 wxPyApp *arg1 = (wxPyApp *) 0 ;
27278 bool result;
27279 void *argp1 = 0 ;
27280 int res1 = 0 ;
27281 PyObject *swig_obj[1] ;
27282
27283 if (!args) SWIG_fail;
27284 swig_obj[0] = args;
27285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27286 if (!SWIG_IsOK(res1)) {
27287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27288 }
27289 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27290 {
27291 PyThreadState* __tstate = wxPyBeginAllowThreads();
27292 result = (bool)(arg1)->Dispatch();
27293 wxPyEndAllowThreads(__tstate);
27294 if (PyErr_Occurred()) SWIG_fail;
27295 }
27296 {
27297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27298 }
27299 return resultobj;
27300 fail:
27301 return NULL;
27302 }
27303
27304
27305 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27306 PyObject *resultobj = 0;
27307 wxPyApp *arg1 = (wxPyApp *) 0 ;
27308 bool result;
27309 void *argp1 = 0 ;
27310 int res1 = 0 ;
27311 PyObject *swig_obj[1] ;
27312
27313 if (!args) SWIG_fail;
27314 swig_obj[0] = args;
27315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27316 if (!SWIG_IsOK(res1)) {
27317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27318 }
27319 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27320 {
27321 PyThreadState* __tstate = wxPyBeginAllowThreads();
27322 result = (bool)(arg1)->ProcessIdle();
27323 wxPyEndAllowThreads(__tstate);
27324 if (PyErr_Occurred()) SWIG_fail;
27325 }
27326 {
27327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27328 }
27329 return resultobj;
27330 fail:
27331 return NULL;
27332 }
27333
27334
27335 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27336 PyObject *resultobj = 0;
27337 wxPyApp *arg1 = (wxPyApp *) 0 ;
27338 wxWindow *arg2 = (wxWindow *) 0 ;
27339 wxIdleEvent *arg3 = 0 ;
27340 bool result;
27341 void *argp1 = 0 ;
27342 int res1 = 0 ;
27343 void *argp2 = 0 ;
27344 int res2 = 0 ;
27345 void *argp3 = 0 ;
27346 int res3 = 0 ;
27347 PyObject * obj0 = 0 ;
27348 PyObject * obj1 = 0 ;
27349 PyObject * obj2 = 0 ;
27350 char * kwnames[] = {
27351 (char *) "self",(char *) "win",(char *) "event", NULL
27352 };
27353
27354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27356 if (!SWIG_IsOK(res1)) {
27357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27358 }
27359 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27360 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27361 if (!SWIG_IsOK(res2)) {
27362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27363 }
27364 arg2 = reinterpret_cast< wxWindow * >(argp2);
27365 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27366 if (!SWIG_IsOK(res3)) {
27367 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27368 }
27369 if (!argp3) {
27370 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27371 }
27372 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27373 {
27374 PyThreadState* __tstate = wxPyBeginAllowThreads();
27375 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27376 wxPyEndAllowThreads(__tstate);
27377 if (PyErr_Occurred()) SWIG_fail;
27378 }
27379 {
27380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27381 }
27382 return resultobj;
27383 fail:
27384 return NULL;
27385 }
27386
27387
27388 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27389 PyObject *resultobj = 0;
27390 wxPyApp *arg1 = (wxPyApp *) 0 ;
27391 bool result;
27392 void *argp1 = 0 ;
27393 int res1 = 0 ;
27394 PyObject *swig_obj[1] ;
27395
27396 if (!args) SWIG_fail;
27397 swig_obj[0] = args;
27398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27399 if (!SWIG_IsOK(res1)) {
27400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27401 }
27402 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27403 {
27404 PyThreadState* __tstate = wxPyBeginAllowThreads();
27405 result = (bool)((wxPyApp const *)arg1)->IsActive();
27406 wxPyEndAllowThreads(__tstate);
27407 if (PyErr_Occurred()) SWIG_fail;
27408 }
27409 {
27410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27411 }
27412 return resultobj;
27413 fail:
27414 return NULL;
27415 }
27416
27417
27418 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27419 PyObject *resultobj = 0;
27420 wxPyApp *arg1 = (wxPyApp *) 0 ;
27421 wxWindow *arg2 = (wxWindow *) 0 ;
27422 void *argp1 = 0 ;
27423 int res1 = 0 ;
27424 void *argp2 = 0 ;
27425 int res2 = 0 ;
27426 PyObject * obj0 = 0 ;
27427 PyObject * obj1 = 0 ;
27428 char * kwnames[] = {
27429 (char *) "self",(char *) "win", NULL
27430 };
27431
27432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27434 if (!SWIG_IsOK(res1)) {
27435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27436 }
27437 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27438 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27439 if (!SWIG_IsOK(res2)) {
27440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27441 }
27442 arg2 = reinterpret_cast< wxWindow * >(argp2);
27443 {
27444 PyThreadState* __tstate = wxPyBeginAllowThreads();
27445 (arg1)->SetTopWindow(arg2);
27446 wxPyEndAllowThreads(__tstate);
27447 if (PyErr_Occurred()) SWIG_fail;
27448 }
27449 resultobj = SWIG_Py_Void();
27450 return resultobj;
27451 fail:
27452 return NULL;
27453 }
27454
27455
27456 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27457 PyObject *resultobj = 0;
27458 wxPyApp *arg1 = (wxPyApp *) 0 ;
27459 wxWindow *result = 0 ;
27460 void *argp1 = 0 ;
27461 int res1 = 0 ;
27462 PyObject *swig_obj[1] ;
27463
27464 if (!args) SWIG_fail;
27465 swig_obj[0] = args;
27466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27467 if (!SWIG_IsOK(res1)) {
27468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27469 }
27470 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27471 {
27472 PyThreadState* __tstate = wxPyBeginAllowThreads();
27473 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27474 wxPyEndAllowThreads(__tstate);
27475 if (PyErr_Occurred()) SWIG_fail;
27476 }
27477 {
27478 resultobj = wxPyMake_wxObject(result, (bool)0);
27479 }
27480 return resultobj;
27481 fail:
27482 return NULL;
27483 }
27484
27485
27486 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27487 PyObject *resultobj = 0;
27488 wxPyApp *arg1 = (wxPyApp *) 0 ;
27489 bool arg2 ;
27490 void *argp1 = 0 ;
27491 int res1 = 0 ;
27492 bool val2 ;
27493 int ecode2 = 0 ;
27494 PyObject * obj0 = 0 ;
27495 PyObject * obj1 = 0 ;
27496 char * kwnames[] = {
27497 (char *) "self",(char *) "flag", NULL
27498 };
27499
27500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27502 if (!SWIG_IsOK(res1)) {
27503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27504 }
27505 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27506 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27507 if (!SWIG_IsOK(ecode2)) {
27508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27509 }
27510 arg2 = static_cast< bool >(val2);
27511 {
27512 PyThreadState* __tstate = wxPyBeginAllowThreads();
27513 (arg1)->SetExitOnFrameDelete(arg2);
27514 wxPyEndAllowThreads(__tstate);
27515 if (PyErr_Occurred()) SWIG_fail;
27516 }
27517 resultobj = SWIG_Py_Void();
27518 return resultobj;
27519 fail:
27520 return NULL;
27521 }
27522
27523
27524 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27525 PyObject *resultobj = 0;
27526 wxPyApp *arg1 = (wxPyApp *) 0 ;
27527 bool result;
27528 void *argp1 = 0 ;
27529 int res1 = 0 ;
27530 PyObject *swig_obj[1] ;
27531
27532 if (!args) SWIG_fail;
27533 swig_obj[0] = args;
27534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27535 if (!SWIG_IsOK(res1)) {
27536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27537 }
27538 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27539 {
27540 PyThreadState* __tstate = wxPyBeginAllowThreads();
27541 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27542 wxPyEndAllowThreads(__tstate);
27543 if (PyErr_Occurred()) SWIG_fail;
27544 }
27545 {
27546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27547 }
27548 return resultobj;
27549 fail:
27550 return NULL;
27551 }
27552
27553
27554 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27555 PyObject *resultobj = 0;
27556 wxPyApp *arg1 = (wxPyApp *) 0 ;
27557 bool arg2 ;
27558 void *argp1 = 0 ;
27559 int res1 = 0 ;
27560 bool val2 ;
27561 int ecode2 = 0 ;
27562 PyObject * obj0 = 0 ;
27563 PyObject * obj1 = 0 ;
27564 char * kwnames[] = {
27565 (char *) "self",(char *) "flag", NULL
27566 };
27567
27568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27570 if (!SWIG_IsOK(res1)) {
27571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27572 }
27573 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27574 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27575 if (!SWIG_IsOK(ecode2)) {
27576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27577 }
27578 arg2 = static_cast< bool >(val2);
27579 {
27580 PyThreadState* __tstate = wxPyBeginAllowThreads();
27581 (arg1)->SetUseBestVisual(arg2);
27582 wxPyEndAllowThreads(__tstate);
27583 if (PyErr_Occurred()) SWIG_fail;
27584 }
27585 resultobj = SWIG_Py_Void();
27586 return resultobj;
27587 fail:
27588 return NULL;
27589 }
27590
27591
27592 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27593 PyObject *resultobj = 0;
27594 wxPyApp *arg1 = (wxPyApp *) 0 ;
27595 bool result;
27596 void *argp1 = 0 ;
27597 int res1 = 0 ;
27598 PyObject *swig_obj[1] ;
27599
27600 if (!args) SWIG_fail;
27601 swig_obj[0] = args;
27602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27603 if (!SWIG_IsOK(res1)) {
27604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27605 }
27606 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27607 {
27608 PyThreadState* __tstate = wxPyBeginAllowThreads();
27609 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27610 wxPyEndAllowThreads(__tstate);
27611 if (PyErr_Occurred()) SWIG_fail;
27612 }
27613 {
27614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27615 }
27616 return resultobj;
27617 fail:
27618 return NULL;
27619 }
27620
27621
27622 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27623 PyObject *resultobj = 0;
27624 wxPyApp *arg1 = (wxPyApp *) 0 ;
27625 int arg2 ;
27626 void *argp1 = 0 ;
27627 int res1 = 0 ;
27628 int val2 ;
27629 int ecode2 = 0 ;
27630 PyObject * obj0 = 0 ;
27631 PyObject * obj1 = 0 ;
27632 char * kwnames[] = {
27633 (char *) "self",(char *) "mode", NULL
27634 };
27635
27636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27638 if (!SWIG_IsOK(res1)) {
27639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27640 }
27641 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27642 ecode2 = SWIG_AsVal_int(obj1, &val2);
27643 if (!SWIG_IsOK(ecode2)) {
27644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27645 }
27646 arg2 = static_cast< int >(val2);
27647 {
27648 PyThreadState* __tstate = wxPyBeginAllowThreads();
27649 (arg1)->SetPrintMode(arg2);
27650 wxPyEndAllowThreads(__tstate);
27651 if (PyErr_Occurred()) SWIG_fail;
27652 }
27653 resultobj = SWIG_Py_Void();
27654 return resultobj;
27655 fail:
27656 return NULL;
27657 }
27658
27659
27660 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27661 PyObject *resultobj = 0;
27662 wxPyApp *arg1 = (wxPyApp *) 0 ;
27663 int result;
27664 void *argp1 = 0 ;
27665 int res1 = 0 ;
27666 PyObject *swig_obj[1] ;
27667
27668 if (!args) SWIG_fail;
27669 swig_obj[0] = args;
27670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27671 if (!SWIG_IsOK(res1)) {
27672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27673 }
27674 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27675 {
27676 PyThreadState* __tstate = wxPyBeginAllowThreads();
27677 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27678 wxPyEndAllowThreads(__tstate);
27679 if (PyErr_Occurred()) SWIG_fail;
27680 }
27681 resultobj = SWIG_From_int(static_cast< int >(result));
27682 return resultobj;
27683 fail:
27684 return NULL;
27685 }
27686
27687
27688 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27689 PyObject *resultobj = 0;
27690 wxPyApp *arg1 = (wxPyApp *) 0 ;
27691 int arg2 ;
27692 void *argp1 = 0 ;
27693 int res1 = 0 ;
27694 int val2 ;
27695 int ecode2 = 0 ;
27696 PyObject * obj0 = 0 ;
27697 PyObject * obj1 = 0 ;
27698 char * kwnames[] = {
27699 (char *) "self",(char *) "mode", NULL
27700 };
27701
27702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27704 if (!SWIG_IsOK(res1)) {
27705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27706 }
27707 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27708 ecode2 = SWIG_AsVal_int(obj1, &val2);
27709 if (!SWIG_IsOK(ecode2)) {
27710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27711 }
27712 arg2 = static_cast< int >(val2);
27713 {
27714 PyThreadState* __tstate = wxPyBeginAllowThreads();
27715 (arg1)->SetAssertMode(arg2);
27716 wxPyEndAllowThreads(__tstate);
27717 if (PyErr_Occurred()) SWIG_fail;
27718 }
27719 resultobj = SWIG_Py_Void();
27720 return resultobj;
27721 fail:
27722 return NULL;
27723 }
27724
27725
27726 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27727 PyObject *resultobj = 0;
27728 wxPyApp *arg1 = (wxPyApp *) 0 ;
27729 int result;
27730 void *argp1 = 0 ;
27731 int res1 = 0 ;
27732 PyObject *swig_obj[1] ;
27733
27734 if (!args) SWIG_fail;
27735 swig_obj[0] = args;
27736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27737 if (!SWIG_IsOK(res1)) {
27738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27739 }
27740 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27741 {
27742 PyThreadState* __tstate = wxPyBeginAllowThreads();
27743 result = (int)(arg1)->GetAssertMode();
27744 wxPyEndAllowThreads(__tstate);
27745 if (PyErr_Occurred()) SWIG_fail;
27746 }
27747 resultobj = SWIG_From_int(static_cast< int >(result));
27748 return resultobj;
27749 fail:
27750 return NULL;
27751 }
27752
27753
27754 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27755 PyObject *resultobj = 0;
27756 bool result;
27757
27758 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27759 {
27760 PyThreadState* __tstate = wxPyBeginAllowThreads();
27761 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27762 wxPyEndAllowThreads(__tstate);
27763 if (PyErr_Occurred()) SWIG_fail;
27764 }
27765 {
27766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27767 }
27768 return resultobj;
27769 fail:
27770 return NULL;
27771 }
27772
27773
27774 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27775 PyObject *resultobj = 0;
27776 long result;
27777
27778 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27779 {
27780 PyThreadState* __tstate = wxPyBeginAllowThreads();
27781 result = (long)wxPyApp::GetMacAboutMenuItemId();
27782 wxPyEndAllowThreads(__tstate);
27783 if (PyErr_Occurred()) SWIG_fail;
27784 }
27785 resultobj = SWIG_From_long(static_cast< long >(result));
27786 return resultobj;
27787 fail:
27788 return NULL;
27789 }
27790
27791
27792 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27793 PyObject *resultobj = 0;
27794 long result;
27795
27796 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27797 {
27798 PyThreadState* __tstate = wxPyBeginAllowThreads();
27799 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27800 wxPyEndAllowThreads(__tstate);
27801 if (PyErr_Occurred()) SWIG_fail;
27802 }
27803 resultobj = SWIG_From_long(static_cast< long >(result));
27804 return resultobj;
27805 fail:
27806 return NULL;
27807 }
27808
27809
27810 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27811 PyObject *resultobj = 0;
27812 long result;
27813
27814 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27815 {
27816 PyThreadState* __tstate = wxPyBeginAllowThreads();
27817 result = (long)wxPyApp::GetMacExitMenuItemId();
27818 wxPyEndAllowThreads(__tstate);
27819 if (PyErr_Occurred()) SWIG_fail;
27820 }
27821 resultobj = SWIG_From_long(static_cast< long >(result));
27822 return resultobj;
27823 fail:
27824 return NULL;
27825 }
27826
27827
27828 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27829 PyObject *resultobj = 0;
27830 wxString result;
27831
27832 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27833 {
27834 PyThreadState* __tstate = wxPyBeginAllowThreads();
27835 result = wxPyApp::GetMacHelpMenuTitleName();
27836 wxPyEndAllowThreads(__tstate);
27837 if (PyErr_Occurred()) SWIG_fail;
27838 }
27839 {
27840 #if wxUSE_UNICODE
27841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27842 #else
27843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27844 #endif
27845 }
27846 return resultobj;
27847 fail:
27848 return NULL;
27849 }
27850
27851
27852 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27853 PyObject *resultobj = 0;
27854 bool arg1 ;
27855 bool val1 ;
27856 int ecode1 = 0 ;
27857 PyObject * obj0 = 0 ;
27858 char * kwnames[] = {
27859 (char *) "val", NULL
27860 };
27861
27862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27863 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27864 if (!SWIG_IsOK(ecode1)) {
27865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27866 }
27867 arg1 = static_cast< bool >(val1);
27868 {
27869 PyThreadState* __tstate = wxPyBeginAllowThreads();
27870 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
27871 wxPyEndAllowThreads(__tstate);
27872 if (PyErr_Occurred()) SWIG_fail;
27873 }
27874 resultobj = SWIG_Py_Void();
27875 return resultobj;
27876 fail:
27877 return NULL;
27878 }
27879
27880
27881 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27882 PyObject *resultobj = 0;
27883 long arg1 ;
27884 long val1 ;
27885 int ecode1 = 0 ;
27886 PyObject * obj0 = 0 ;
27887 char * kwnames[] = {
27888 (char *) "val", NULL
27889 };
27890
27891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
27892 ecode1 = SWIG_AsVal_long(obj0, &val1);
27893 if (!SWIG_IsOK(ecode1)) {
27894 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
27895 }
27896 arg1 = static_cast< long >(val1);
27897 {
27898 PyThreadState* __tstate = wxPyBeginAllowThreads();
27899 wxPyApp::SetMacAboutMenuItemId(arg1);
27900 wxPyEndAllowThreads(__tstate);
27901 if (PyErr_Occurred()) SWIG_fail;
27902 }
27903 resultobj = SWIG_Py_Void();
27904 return resultobj;
27905 fail:
27906 return NULL;
27907 }
27908
27909
27910 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27911 PyObject *resultobj = 0;
27912 long arg1 ;
27913 long val1 ;
27914 int ecode1 = 0 ;
27915 PyObject * obj0 = 0 ;
27916 char * kwnames[] = {
27917 (char *) "val", NULL
27918 };
27919
27920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
27921 ecode1 = SWIG_AsVal_long(obj0, &val1);
27922 if (!SWIG_IsOK(ecode1)) {
27923 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
27924 }
27925 arg1 = static_cast< long >(val1);
27926 {
27927 PyThreadState* __tstate = wxPyBeginAllowThreads();
27928 wxPyApp::SetMacPreferencesMenuItemId(arg1);
27929 wxPyEndAllowThreads(__tstate);
27930 if (PyErr_Occurred()) SWIG_fail;
27931 }
27932 resultobj = SWIG_Py_Void();
27933 return resultobj;
27934 fail:
27935 return NULL;
27936 }
27937
27938
27939 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27940 PyObject *resultobj = 0;
27941 long arg1 ;
27942 long val1 ;
27943 int ecode1 = 0 ;
27944 PyObject * obj0 = 0 ;
27945 char * kwnames[] = {
27946 (char *) "val", NULL
27947 };
27948
27949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
27950 ecode1 = SWIG_AsVal_long(obj0, &val1);
27951 if (!SWIG_IsOK(ecode1)) {
27952 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
27953 }
27954 arg1 = static_cast< long >(val1);
27955 {
27956 PyThreadState* __tstate = wxPyBeginAllowThreads();
27957 wxPyApp::SetMacExitMenuItemId(arg1);
27958 wxPyEndAllowThreads(__tstate);
27959 if (PyErr_Occurred()) SWIG_fail;
27960 }
27961 resultobj = SWIG_Py_Void();
27962 return resultobj;
27963 fail:
27964 return NULL;
27965 }
27966
27967
27968 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27969 PyObject *resultobj = 0;
27970 wxString *arg1 = 0 ;
27971 bool temp1 = false ;
27972 PyObject * obj0 = 0 ;
27973 char * kwnames[] = {
27974 (char *) "val", NULL
27975 };
27976
27977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
27978 {
27979 arg1 = wxString_in_helper(obj0);
27980 if (arg1 == NULL) SWIG_fail;
27981 temp1 = true;
27982 }
27983 {
27984 PyThreadState* __tstate = wxPyBeginAllowThreads();
27985 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
27986 wxPyEndAllowThreads(__tstate);
27987 if (PyErr_Occurred()) SWIG_fail;
27988 }
27989 resultobj = SWIG_Py_Void();
27990 {
27991 if (temp1)
27992 delete arg1;
27993 }
27994 return resultobj;
27995 fail:
27996 {
27997 if (temp1)
27998 delete arg1;
27999 }
28000 return NULL;
28001 }
28002
28003
28004 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28005 PyObject *resultobj = 0;
28006 wxPyApp *arg1 = (wxPyApp *) 0 ;
28007 void *argp1 = 0 ;
28008 int res1 = 0 ;
28009 PyObject *swig_obj[1] ;
28010
28011 if (!args) SWIG_fail;
28012 swig_obj[0] = args;
28013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28014 if (!SWIG_IsOK(res1)) {
28015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28016 }
28017 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28018 {
28019 PyThreadState* __tstate = wxPyBeginAllowThreads();
28020 (arg1)->_BootstrapApp();
28021 wxPyEndAllowThreads(__tstate);
28022 if (PyErr_Occurred()) SWIG_fail;
28023 }
28024 resultobj = SWIG_Py_Void();
28025 return resultobj;
28026 fail:
28027 return NULL;
28028 }
28029
28030
28031 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28032 PyObject *resultobj = 0;
28033 int result;
28034
28035 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28036 {
28037 PyThreadState* __tstate = wxPyBeginAllowThreads();
28038 result = (int)wxPyApp::GetComCtl32Version();
28039 wxPyEndAllowThreads(__tstate);
28040 if (PyErr_Occurred()) SWIG_fail;
28041 }
28042 resultobj = SWIG_From_int(static_cast< int >(result));
28043 return resultobj;
28044 fail:
28045 return NULL;
28046 }
28047
28048
28049 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28050 PyObject *obj;
28051 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28052 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28053 return SWIG_Py_Void();
28054 }
28055
28056 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28057 return SWIG_Python_InitShadowInstance(args);
28058 }
28059
28060 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28061 PyObject *resultobj = 0;
28062
28063 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28064 {
28065 PyThreadState* __tstate = wxPyBeginAllowThreads();
28066 wxExit();
28067 wxPyEndAllowThreads(__tstate);
28068 if (PyErr_Occurred()) SWIG_fail;
28069 }
28070 resultobj = SWIG_Py_Void();
28071 return resultobj;
28072 fail:
28073 return NULL;
28074 }
28075
28076
28077 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28078 PyObject *resultobj = 0;
28079 bool result;
28080
28081 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28082 {
28083 PyThreadState* __tstate = wxPyBeginAllowThreads();
28084 result = (bool)wxYield();
28085 wxPyEndAllowThreads(__tstate);
28086 if (PyErr_Occurred()) SWIG_fail;
28087 }
28088 {
28089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28090 }
28091 return resultobj;
28092 fail:
28093 return NULL;
28094 }
28095
28096
28097 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28098 PyObject *resultobj = 0;
28099 bool result;
28100
28101 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28102 {
28103 PyThreadState* __tstate = wxPyBeginAllowThreads();
28104 result = (bool)wxYieldIfNeeded();
28105 wxPyEndAllowThreads(__tstate);
28106 if (PyErr_Occurred()) SWIG_fail;
28107 }
28108 {
28109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28110 }
28111 return resultobj;
28112 fail:
28113 return NULL;
28114 }
28115
28116
28117 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28118 PyObject *resultobj = 0;
28119 wxWindow *arg1 = (wxWindow *) NULL ;
28120 bool arg2 = (bool) false ;
28121 bool result;
28122 void *argp1 = 0 ;
28123 int res1 = 0 ;
28124 bool val2 ;
28125 int ecode2 = 0 ;
28126 PyObject * obj0 = 0 ;
28127 PyObject * obj1 = 0 ;
28128 char * kwnames[] = {
28129 (char *) "win",(char *) "onlyIfNeeded", NULL
28130 };
28131
28132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28133 if (obj0) {
28134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28135 if (!SWIG_IsOK(res1)) {
28136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28137 }
28138 arg1 = reinterpret_cast< wxWindow * >(argp1);
28139 }
28140 if (obj1) {
28141 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28142 if (!SWIG_IsOK(ecode2)) {
28143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28144 }
28145 arg2 = static_cast< bool >(val2);
28146 }
28147 {
28148 PyThreadState* __tstate = wxPyBeginAllowThreads();
28149 result = (bool)wxSafeYield(arg1,arg2);
28150 wxPyEndAllowThreads(__tstate);
28151 if (PyErr_Occurred()) SWIG_fail;
28152 }
28153 {
28154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28155 }
28156 return resultobj;
28157 fail:
28158 return NULL;
28159 }
28160
28161
28162 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28163 PyObject *resultobj = 0;
28164
28165 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28166 {
28167 PyThreadState* __tstate = wxPyBeginAllowThreads();
28168 wxWakeUpIdle();
28169 wxPyEndAllowThreads(__tstate);
28170 if (PyErr_Occurred()) SWIG_fail;
28171 }
28172 resultobj = SWIG_Py_Void();
28173 return resultobj;
28174 fail:
28175 return NULL;
28176 }
28177
28178
28179 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28180 PyObject *resultobj = 0;
28181 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28182 wxEvent *arg2 = 0 ;
28183 void *argp1 = 0 ;
28184 int res1 = 0 ;
28185 void *argp2 = 0 ;
28186 int res2 = 0 ;
28187 PyObject * obj0 = 0 ;
28188 PyObject * obj1 = 0 ;
28189 char * kwnames[] = {
28190 (char *) "dest",(char *) "event", NULL
28191 };
28192
28193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28195 if (!SWIG_IsOK(res1)) {
28196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28197 }
28198 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28199 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28200 if (!SWIG_IsOK(res2)) {
28201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28202 }
28203 if (!argp2) {
28204 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28205 }
28206 arg2 = reinterpret_cast< wxEvent * >(argp2);
28207 {
28208 PyThreadState* __tstate = wxPyBeginAllowThreads();
28209 wxPostEvent(arg1,*arg2);
28210 wxPyEndAllowThreads(__tstate);
28211 if (PyErr_Occurred()) SWIG_fail;
28212 }
28213 resultobj = SWIG_Py_Void();
28214 return resultobj;
28215 fail:
28216 return NULL;
28217 }
28218
28219
28220 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28221 PyObject *resultobj = 0;
28222
28223 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28224 {
28225 PyThreadState* __tstate = wxPyBeginAllowThreads();
28226 wxApp_CleanUp();
28227 wxPyEndAllowThreads(__tstate);
28228 if (PyErr_Occurred()) SWIG_fail;
28229 }
28230 resultobj = SWIG_Py_Void();
28231 return resultobj;
28232 fail:
28233 return NULL;
28234 }
28235
28236
28237 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28238 PyObject *resultobj = 0;
28239 wxPyApp *result = 0 ;
28240
28241 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28242 {
28243 PyThreadState* __tstate = wxPyBeginAllowThreads();
28244 result = (wxPyApp *)wxPyGetApp();
28245 wxPyEndAllowThreads(__tstate);
28246 if (PyErr_Occurred()) SWIG_fail;
28247 }
28248 {
28249 resultobj = wxPyMake_wxObject(result, 0);
28250 }
28251 return resultobj;
28252 fail:
28253 return NULL;
28254 }
28255
28256
28257 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28258 PyObject *resultobj = 0;
28259 char *arg1 = (char *) 0 ;
28260 int res1 ;
28261 char *buf1 = 0 ;
28262 int alloc1 = 0 ;
28263 PyObject * obj0 = 0 ;
28264 char * kwnames[] = {
28265 (char *) "encoding", NULL
28266 };
28267
28268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28269 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28270 if (!SWIG_IsOK(res1)) {
28271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28272 }
28273 arg1 = buf1;
28274 {
28275 PyThreadState* __tstate = wxPyBeginAllowThreads();
28276 wxSetDefaultPyEncoding((char const *)arg1);
28277 wxPyEndAllowThreads(__tstate);
28278 if (PyErr_Occurred()) SWIG_fail;
28279 }
28280 resultobj = SWIG_Py_Void();
28281 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28282 return resultobj;
28283 fail:
28284 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28285 return NULL;
28286 }
28287
28288
28289 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28290 PyObject *resultobj = 0;
28291 char *result = 0 ;
28292
28293 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28294 {
28295 PyThreadState* __tstate = wxPyBeginAllowThreads();
28296 result = (char *)wxGetDefaultPyEncoding();
28297 wxPyEndAllowThreads(__tstate);
28298 if (PyErr_Occurred()) SWIG_fail;
28299 }
28300 resultobj = SWIG_FromCharPtr(result);
28301 return resultobj;
28302 fail:
28303 return NULL;
28304 }
28305
28306
28307 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28308 PyObject *resultobj = 0;
28309 wxEventLoop *result = 0 ;
28310
28311 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 result = (wxEventLoop *)new wxEventLoop();
28315 wxPyEndAllowThreads(__tstate);
28316 if (PyErr_Occurred()) SWIG_fail;
28317 }
28318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28319 return resultobj;
28320 fail:
28321 return NULL;
28322 }
28323
28324
28325 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28326 PyObject *resultobj = 0;
28327 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28328 void *argp1 = 0 ;
28329 int res1 = 0 ;
28330 PyObject *swig_obj[1] ;
28331
28332 if (!args) SWIG_fail;
28333 swig_obj[0] = args;
28334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28335 if (!SWIG_IsOK(res1)) {
28336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28337 }
28338 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28339 {
28340 PyThreadState* __tstate = wxPyBeginAllowThreads();
28341 delete arg1;
28342
28343 wxPyEndAllowThreads(__tstate);
28344 if (PyErr_Occurred()) SWIG_fail;
28345 }
28346 resultobj = SWIG_Py_Void();
28347 return resultobj;
28348 fail:
28349 return NULL;
28350 }
28351
28352
28353 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28354 PyObject *resultobj = 0;
28355 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28356 int result;
28357 void *argp1 = 0 ;
28358 int res1 = 0 ;
28359 PyObject *swig_obj[1] ;
28360
28361 if (!args) SWIG_fail;
28362 swig_obj[0] = args;
28363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28364 if (!SWIG_IsOK(res1)) {
28365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28366 }
28367 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28368 {
28369 PyThreadState* __tstate = wxPyBeginAllowThreads();
28370 result = (int)(arg1)->Run();
28371 wxPyEndAllowThreads(__tstate);
28372 if (PyErr_Occurred()) SWIG_fail;
28373 }
28374 resultobj = SWIG_From_int(static_cast< int >(result));
28375 return resultobj;
28376 fail:
28377 return NULL;
28378 }
28379
28380
28381 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28382 PyObject *resultobj = 0;
28383 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28384 int arg2 = (int) 0 ;
28385 void *argp1 = 0 ;
28386 int res1 = 0 ;
28387 int val2 ;
28388 int ecode2 = 0 ;
28389 PyObject * obj0 = 0 ;
28390 PyObject * obj1 = 0 ;
28391 char * kwnames[] = {
28392 (char *) "self",(char *) "rc", NULL
28393 };
28394
28395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28397 if (!SWIG_IsOK(res1)) {
28398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28399 }
28400 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28401 if (obj1) {
28402 ecode2 = SWIG_AsVal_int(obj1, &val2);
28403 if (!SWIG_IsOK(ecode2)) {
28404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28405 }
28406 arg2 = static_cast< int >(val2);
28407 }
28408 {
28409 PyThreadState* __tstate = wxPyBeginAllowThreads();
28410 (arg1)->Exit(arg2);
28411 wxPyEndAllowThreads(__tstate);
28412 if (PyErr_Occurred()) SWIG_fail;
28413 }
28414 resultobj = SWIG_Py_Void();
28415 return resultobj;
28416 fail:
28417 return NULL;
28418 }
28419
28420
28421 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28422 PyObject *resultobj = 0;
28423 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28424 bool result;
28425 void *argp1 = 0 ;
28426 int res1 = 0 ;
28427 PyObject *swig_obj[1] ;
28428
28429 if (!args) SWIG_fail;
28430 swig_obj[0] = args;
28431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28432 if (!SWIG_IsOK(res1)) {
28433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28434 }
28435 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28436 {
28437 PyThreadState* __tstate = wxPyBeginAllowThreads();
28438 result = (bool)((wxEventLoop const *)arg1)->Pending();
28439 wxPyEndAllowThreads(__tstate);
28440 if (PyErr_Occurred()) SWIG_fail;
28441 }
28442 {
28443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28444 }
28445 return resultobj;
28446 fail:
28447 return NULL;
28448 }
28449
28450
28451 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28452 PyObject *resultobj = 0;
28453 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28454 bool result;
28455 void *argp1 = 0 ;
28456 int res1 = 0 ;
28457 PyObject *swig_obj[1] ;
28458
28459 if (!args) SWIG_fail;
28460 swig_obj[0] = args;
28461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28462 if (!SWIG_IsOK(res1)) {
28463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28464 }
28465 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28466 {
28467 PyThreadState* __tstate = wxPyBeginAllowThreads();
28468 result = (bool)(arg1)->Dispatch();
28469 wxPyEndAllowThreads(__tstate);
28470 if (PyErr_Occurred()) SWIG_fail;
28471 }
28472 {
28473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28474 }
28475 return resultobj;
28476 fail:
28477 return NULL;
28478 }
28479
28480
28481 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28482 PyObject *resultobj = 0;
28483 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28484 bool result;
28485 void *argp1 = 0 ;
28486 int res1 = 0 ;
28487 PyObject *swig_obj[1] ;
28488
28489 if (!args) SWIG_fail;
28490 swig_obj[0] = args;
28491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28492 if (!SWIG_IsOK(res1)) {
28493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28494 }
28495 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28496 {
28497 PyThreadState* __tstate = wxPyBeginAllowThreads();
28498 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28499 wxPyEndAllowThreads(__tstate);
28500 if (PyErr_Occurred()) SWIG_fail;
28501 }
28502 {
28503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28504 }
28505 return resultobj;
28506 fail:
28507 return NULL;
28508 }
28509
28510
28511 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28512 PyObject *resultobj = 0;
28513 wxEventLoop *result = 0 ;
28514
28515 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28516 {
28517 PyThreadState* __tstate = wxPyBeginAllowThreads();
28518 result = (wxEventLoop *)wxEventLoop::GetActive();
28519 wxPyEndAllowThreads(__tstate);
28520 if (PyErr_Occurred()) SWIG_fail;
28521 }
28522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28523 return resultobj;
28524 fail:
28525 return NULL;
28526 }
28527
28528
28529 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28530 PyObject *resultobj = 0;
28531 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28532 void *argp1 = 0 ;
28533 int res1 = 0 ;
28534 PyObject * obj0 = 0 ;
28535 char * kwnames[] = {
28536 (char *) "loop", NULL
28537 };
28538
28539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28541 if (!SWIG_IsOK(res1)) {
28542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28543 }
28544 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28545 {
28546 PyThreadState* __tstate = wxPyBeginAllowThreads();
28547 wxEventLoop::SetActive(arg1);
28548 wxPyEndAllowThreads(__tstate);
28549 if (PyErr_Occurred()) SWIG_fail;
28550 }
28551 resultobj = SWIG_Py_Void();
28552 return resultobj;
28553 fail:
28554 return NULL;
28555 }
28556
28557
28558 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28559 PyObject *obj;
28560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28561 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28562 return SWIG_Py_Void();
28563 }
28564
28565 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28566 return SWIG_Python_InitShadowInstance(args);
28567 }
28568
28569 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28570 PyObject *resultobj = 0;
28571 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28572 wxEventLoopActivator *result = 0 ;
28573 void *argp1 = 0 ;
28574 int res1 = 0 ;
28575 PyObject * obj0 = 0 ;
28576 char * kwnames[] = {
28577 (char *) "evtLoop", NULL
28578 };
28579
28580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28582 if (!SWIG_IsOK(res1)) {
28583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28584 }
28585 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28586 {
28587 PyThreadState* __tstate = wxPyBeginAllowThreads();
28588 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28589 wxPyEndAllowThreads(__tstate);
28590 if (PyErr_Occurred()) SWIG_fail;
28591 }
28592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28593 return resultobj;
28594 fail:
28595 return NULL;
28596 }
28597
28598
28599 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28600 PyObject *resultobj = 0;
28601 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28602 void *argp1 = 0 ;
28603 int res1 = 0 ;
28604 PyObject *swig_obj[1] ;
28605
28606 if (!args) SWIG_fail;
28607 swig_obj[0] = args;
28608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28609 if (!SWIG_IsOK(res1)) {
28610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28611 }
28612 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28613 {
28614 PyThreadState* __tstate = wxPyBeginAllowThreads();
28615 delete arg1;
28616
28617 wxPyEndAllowThreads(__tstate);
28618 if (PyErr_Occurred()) SWIG_fail;
28619 }
28620 resultobj = SWIG_Py_Void();
28621 return resultobj;
28622 fail:
28623 return NULL;
28624 }
28625
28626
28627 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28628 PyObject *obj;
28629 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28630 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28631 return SWIG_Py_Void();
28632 }
28633
28634 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28635 return SWIG_Python_InitShadowInstance(args);
28636 }
28637
28638 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28639 PyObject *resultobj = 0;
28640 int arg1 = (int) 0 ;
28641 int arg2 = (int) 0 ;
28642 int arg3 = (int) 0 ;
28643 wxAcceleratorEntry *result = 0 ;
28644 int val1 ;
28645 int ecode1 = 0 ;
28646 int val2 ;
28647 int ecode2 = 0 ;
28648 int val3 ;
28649 int ecode3 = 0 ;
28650 PyObject * obj0 = 0 ;
28651 PyObject * obj1 = 0 ;
28652 PyObject * obj2 = 0 ;
28653 char * kwnames[] = {
28654 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28655 };
28656
28657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28658 if (obj0) {
28659 ecode1 = SWIG_AsVal_int(obj0, &val1);
28660 if (!SWIG_IsOK(ecode1)) {
28661 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28662 }
28663 arg1 = static_cast< int >(val1);
28664 }
28665 if (obj1) {
28666 ecode2 = SWIG_AsVal_int(obj1, &val2);
28667 if (!SWIG_IsOK(ecode2)) {
28668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28669 }
28670 arg2 = static_cast< int >(val2);
28671 }
28672 if (obj2) {
28673 ecode3 = SWIG_AsVal_int(obj2, &val3);
28674 if (!SWIG_IsOK(ecode3)) {
28675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28676 }
28677 arg3 = static_cast< int >(val3);
28678 }
28679 {
28680 PyThreadState* __tstate = wxPyBeginAllowThreads();
28681 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28682 wxPyEndAllowThreads(__tstate);
28683 if (PyErr_Occurred()) SWIG_fail;
28684 }
28685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28686 return resultobj;
28687 fail:
28688 return NULL;
28689 }
28690
28691
28692 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28693 PyObject *resultobj = 0;
28694 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28695 void *argp1 = 0 ;
28696 int res1 = 0 ;
28697 PyObject *swig_obj[1] ;
28698
28699 if (!args) SWIG_fail;
28700 swig_obj[0] = args;
28701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28702 if (!SWIG_IsOK(res1)) {
28703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28704 }
28705 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28706 {
28707 PyThreadState* __tstate = wxPyBeginAllowThreads();
28708 delete arg1;
28709
28710 wxPyEndAllowThreads(__tstate);
28711 if (PyErr_Occurred()) SWIG_fail;
28712 }
28713 resultobj = SWIG_Py_Void();
28714 return resultobj;
28715 fail:
28716 return NULL;
28717 }
28718
28719
28720 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28721 PyObject *resultobj = 0;
28722 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28723 int arg2 ;
28724 int arg3 ;
28725 int arg4 ;
28726 void *argp1 = 0 ;
28727 int res1 = 0 ;
28728 int val2 ;
28729 int ecode2 = 0 ;
28730 int val3 ;
28731 int ecode3 = 0 ;
28732 int val4 ;
28733 int ecode4 = 0 ;
28734 PyObject * obj0 = 0 ;
28735 PyObject * obj1 = 0 ;
28736 PyObject * obj2 = 0 ;
28737 PyObject * obj3 = 0 ;
28738 char * kwnames[] = {
28739 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28740 };
28741
28742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28744 if (!SWIG_IsOK(res1)) {
28745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28746 }
28747 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28748 ecode2 = SWIG_AsVal_int(obj1, &val2);
28749 if (!SWIG_IsOK(ecode2)) {
28750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28751 }
28752 arg2 = static_cast< int >(val2);
28753 ecode3 = SWIG_AsVal_int(obj2, &val3);
28754 if (!SWIG_IsOK(ecode3)) {
28755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28756 }
28757 arg3 = static_cast< int >(val3);
28758 ecode4 = SWIG_AsVal_int(obj3, &val4);
28759 if (!SWIG_IsOK(ecode4)) {
28760 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28761 }
28762 arg4 = static_cast< int >(val4);
28763 {
28764 PyThreadState* __tstate = wxPyBeginAllowThreads();
28765 (arg1)->Set(arg2,arg3,arg4);
28766 wxPyEndAllowThreads(__tstate);
28767 if (PyErr_Occurred()) SWIG_fail;
28768 }
28769 resultobj = SWIG_Py_Void();
28770 return resultobj;
28771 fail:
28772 return NULL;
28773 }
28774
28775
28776 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28777 PyObject *resultobj = 0;
28778 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28779 int result;
28780 void *argp1 = 0 ;
28781 int res1 = 0 ;
28782 PyObject *swig_obj[1] ;
28783
28784 if (!args) SWIG_fail;
28785 swig_obj[0] = args;
28786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28787 if (!SWIG_IsOK(res1)) {
28788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28789 }
28790 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28791 {
28792 PyThreadState* __tstate = wxPyBeginAllowThreads();
28793 result = (int)(arg1)->GetFlags();
28794 wxPyEndAllowThreads(__tstate);
28795 if (PyErr_Occurred()) SWIG_fail;
28796 }
28797 resultobj = SWIG_From_int(static_cast< int >(result));
28798 return resultobj;
28799 fail:
28800 return NULL;
28801 }
28802
28803
28804 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28805 PyObject *resultobj = 0;
28806 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28807 int result;
28808 void *argp1 = 0 ;
28809 int res1 = 0 ;
28810 PyObject *swig_obj[1] ;
28811
28812 if (!args) SWIG_fail;
28813 swig_obj[0] = args;
28814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28815 if (!SWIG_IsOK(res1)) {
28816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28817 }
28818 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28819 {
28820 PyThreadState* __tstate = wxPyBeginAllowThreads();
28821 result = (int)(arg1)->GetKeyCode();
28822 wxPyEndAllowThreads(__tstate);
28823 if (PyErr_Occurred()) SWIG_fail;
28824 }
28825 resultobj = SWIG_From_int(static_cast< int >(result));
28826 return resultobj;
28827 fail:
28828 return NULL;
28829 }
28830
28831
28832 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28833 PyObject *resultobj = 0;
28834 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28835 int result;
28836 void *argp1 = 0 ;
28837 int res1 = 0 ;
28838 PyObject *swig_obj[1] ;
28839
28840 if (!args) SWIG_fail;
28841 swig_obj[0] = args;
28842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28843 if (!SWIG_IsOK(res1)) {
28844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28845 }
28846 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28847 {
28848 PyThreadState* __tstate = wxPyBeginAllowThreads();
28849 result = (int)(arg1)->GetCommand();
28850 wxPyEndAllowThreads(__tstate);
28851 if (PyErr_Occurred()) SWIG_fail;
28852 }
28853 resultobj = SWIG_From_int(static_cast< int >(result));
28854 return resultobj;
28855 fail:
28856 return NULL;
28857 }
28858
28859
28860 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28861 PyObject *obj;
28862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28863 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28864 return SWIG_Py_Void();
28865 }
28866
28867 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28868 return SWIG_Python_InitShadowInstance(args);
28869 }
28870
28871 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28872 PyObject *resultobj = 0;
28873 int arg1 ;
28874 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28875 wxAcceleratorTable *result = 0 ;
28876 PyObject * obj0 = 0 ;
28877 char * kwnames[] = {
28878 (char *) "n", NULL
28879 };
28880
28881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28882 {
28883 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28884 if (arg2) arg1 = PyList_Size(obj0);
28885 else arg1 = 0;
28886 }
28887 {
28888 PyThreadState* __tstate = wxPyBeginAllowThreads();
28889 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
28890 wxPyEndAllowThreads(__tstate);
28891 if (PyErr_Occurred()) SWIG_fail;
28892 }
28893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
28894 return resultobj;
28895 fail:
28896 return NULL;
28897 }
28898
28899
28900 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28901 PyObject *resultobj = 0;
28902 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28903 void *argp1 = 0 ;
28904 int res1 = 0 ;
28905 PyObject *swig_obj[1] ;
28906
28907 if (!args) SWIG_fail;
28908 swig_obj[0] = args;
28909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
28910 if (!SWIG_IsOK(res1)) {
28911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
28912 }
28913 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28914 {
28915 PyThreadState* __tstate = wxPyBeginAllowThreads();
28916 delete arg1;
28917
28918 wxPyEndAllowThreads(__tstate);
28919 if (PyErr_Occurred()) SWIG_fail;
28920 }
28921 resultobj = SWIG_Py_Void();
28922 return resultobj;
28923 fail:
28924 return NULL;
28925 }
28926
28927
28928 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28929 PyObject *resultobj = 0;
28930 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28931 bool result;
28932 void *argp1 = 0 ;
28933 int res1 = 0 ;
28934 PyObject *swig_obj[1] ;
28935
28936 if (!args) SWIG_fail;
28937 swig_obj[0] = args;
28938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
28939 if (!SWIG_IsOK(res1)) {
28940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
28941 }
28942 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28943 {
28944 PyThreadState* __tstate = wxPyBeginAllowThreads();
28945 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
28946 wxPyEndAllowThreads(__tstate);
28947 if (PyErr_Occurred()) SWIG_fail;
28948 }
28949 {
28950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28951 }
28952 return resultobj;
28953 fail:
28954 return NULL;
28955 }
28956
28957
28958 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28959 PyObject *obj;
28960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28961 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
28962 return SWIG_Py_Void();
28963 }
28964
28965 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28966 return SWIG_Python_InitShadowInstance(args);
28967 }
28968
28969 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
28970 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
28971 return 1;
28972 }
28973
28974
28975 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
28976 PyObject *pyobj = 0;
28977
28978 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
28979 return pyobj;
28980 }
28981
28982
28983 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28984 PyObject *resultobj = 0;
28985 wxString *arg1 = 0 ;
28986 wxAcceleratorEntry *result = 0 ;
28987 bool temp1 = false ;
28988 PyObject * obj0 = 0 ;
28989 char * kwnames[] = {
28990 (char *) "label", NULL
28991 };
28992
28993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
28994 {
28995 arg1 = wxString_in_helper(obj0);
28996 if (arg1 == NULL) SWIG_fail;
28997 temp1 = true;
28998 }
28999 {
29000 PyThreadState* __tstate = wxPyBeginAllowThreads();
29001 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29002 wxPyEndAllowThreads(__tstate);
29003 if (PyErr_Occurred()) SWIG_fail;
29004 }
29005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29006 {
29007 if (temp1)
29008 delete arg1;
29009 }
29010 return resultobj;
29011 fail:
29012 {
29013 if (temp1)
29014 delete arg1;
29015 }
29016 return NULL;
29017 }
29018
29019
29020 SWIGINTERN int PanelNameStr_set(PyObject *) {
29021 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29022 return 1;
29023 }
29024
29025
29026 SWIGINTERN PyObject *PanelNameStr_get(void) {
29027 PyObject *pyobj = 0;
29028
29029 {
29030 #if wxUSE_UNICODE
29031 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29032 #else
29033 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29034 #endif
29035 }
29036 return pyobj;
29037 }
29038
29039
29040 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29041 PyObject *resultobj = 0;
29042 wxVisualAttributes *result = 0 ;
29043
29044 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29045 {
29046 PyThreadState* __tstate = wxPyBeginAllowThreads();
29047 result = (wxVisualAttributes *)new_wxVisualAttributes();
29048 wxPyEndAllowThreads(__tstate);
29049 if (PyErr_Occurred()) SWIG_fail;
29050 }
29051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29052 return resultobj;
29053 fail:
29054 return NULL;
29055 }
29056
29057
29058 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29059 PyObject *resultobj = 0;
29060 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29061 void *argp1 = 0 ;
29062 int res1 = 0 ;
29063 PyObject *swig_obj[1] ;
29064
29065 if (!args) SWIG_fail;
29066 swig_obj[0] = args;
29067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29068 if (!SWIG_IsOK(res1)) {
29069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29070 }
29071 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29072 {
29073 PyThreadState* __tstate = wxPyBeginAllowThreads();
29074 delete_wxVisualAttributes(arg1);
29075
29076 wxPyEndAllowThreads(__tstate);
29077 if (PyErr_Occurred()) SWIG_fail;
29078 }
29079 resultobj = SWIG_Py_Void();
29080 return resultobj;
29081 fail:
29082 return NULL;
29083 }
29084
29085
29086 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29087 PyObject *resultobj = 0;
29088 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29089 wxFont *arg2 = (wxFont *) 0 ;
29090 void *argp1 = 0 ;
29091 int res1 = 0 ;
29092 void *argp2 = 0 ;
29093 int res2 = 0 ;
29094 PyObject *swig_obj[2] ;
29095
29096 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29098 if (!SWIG_IsOK(res1)) {
29099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29100 }
29101 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29102 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29103 if (!SWIG_IsOK(res2)) {
29104 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29105 }
29106 arg2 = reinterpret_cast< wxFont * >(argp2);
29107 if (arg1) (arg1)->font = *arg2;
29108
29109 resultobj = SWIG_Py_Void();
29110 return resultobj;
29111 fail:
29112 return NULL;
29113 }
29114
29115
29116 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29117 PyObject *resultobj = 0;
29118 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29119 wxFont *result = 0 ;
29120 void *argp1 = 0 ;
29121 int res1 = 0 ;
29122 PyObject *swig_obj[1] ;
29123
29124 if (!args) SWIG_fail;
29125 swig_obj[0] = args;
29126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29127 if (!SWIG_IsOK(res1)) {
29128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29129 }
29130 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29131 result = (wxFont *)& ((arg1)->font);
29132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29133 return resultobj;
29134 fail:
29135 return NULL;
29136 }
29137
29138
29139 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29140 PyObject *resultobj = 0;
29141 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29142 wxColour *arg2 = (wxColour *) 0 ;
29143 void *argp1 = 0 ;
29144 int res1 = 0 ;
29145 void *argp2 = 0 ;
29146 int res2 = 0 ;
29147 PyObject *swig_obj[2] ;
29148
29149 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29151 if (!SWIG_IsOK(res1)) {
29152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29153 }
29154 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29155 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29156 if (!SWIG_IsOK(res2)) {
29157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29158 }
29159 arg2 = reinterpret_cast< wxColour * >(argp2);
29160 if (arg1) (arg1)->colFg = *arg2;
29161
29162 resultobj = SWIG_Py_Void();
29163 return resultobj;
29164 fail:
29165 return NULL;
29166 }
29167
29168
29169 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29170 PyObject *resultobj = 0;
29171 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29172 wxColour *result = 0 ;
29173 void *argp1 = 0 ;
29174 int res1 = 0 ;
29175 PyObject *swig_obj[1] ;
29176
29177 if (!args) SWIG_fail;
29178 swig_obj[0] = args;
29179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29180 if (!SWIG_IsOK(res1)) {
29181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29182 }
29183 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29184 result = (wxColour *)& ((arg1)->colFg);
29185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29186 return resultobj;
29187 fail:
29188 return NULL;
29189 }
29190
29191
29192 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29193 PyObject *resultobj = 0;
29194 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29195 wxColour *arg2 = (wxColour *) 0 ;
29196 void *argp1 = 0 ;
29197 int res1 = 0 ;
29198 void *argp2 = 0 ;
29199 int res2 = 0 ;
29200 PyObject *swig_obj[2] ;
29201
29202 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29204 if (!SWIG_IsOK(res1)) {
29205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29206 }
29207 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29208 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29209 if (!SWIG_IsOK(res2)) {
29210 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29211 }
29212 arg2 = reinterpret_cast< wxColour * >(argp2);
29213 if (arg1) (arg1)->colBg = *arg2;
29214
29215 resultobj = SWIG_Py_Void();
29216 return resultobj;
29217 fail:
29218 return NULL;
29219 }
29220
29221
29222 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29223 PyObject *resultobj = 0;
29224 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29225 wxColour *result = 0 ;
29226 void *argp1 = 0 ;
29227 int res1 = 0 ;
29228 PyObject *swig_obj[1] ;
29229
29230 if (!args) SWIG_fail;
29231 swig_obj[0] = args;
29232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29233 if (!SWIG_IsOK(res1)) {
29234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29235 }
29236 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29237 result = (wxColour *)& ((arg1)->colBg);
29238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29239 return resultobj;
29240 fail:
29241 return NULL;
29242 }
29243
29244
29245 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29246 PyObject *obj;
29247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29248 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29249 return SWIG_Py_Void();
29250 }
29251
29252 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29253 return SWIG_Python_InitShadowInstance(args);
29254 }
29255
29256 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29257 PyObject *resultobj = 0;
29258 wxWindow *arg1 = (wxWindow *) 0 ;
29259 int arg2 = (int) (int)-1 ;
29260 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29261 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29262 wxSize const &arg4_defvalue = wxDefaultSize ;
29263 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29264 long arg5 = (long) 0 ;
29265 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29266 wxString *arg6 = (wxString *) &arg6_defvalue ;
29267 wxWindow *result = 0 ;
29268 void *argp1 = 0 ;
29269 int res1 = 0 ;
29270 int val2 ;
29271 int ecode2 = 0 ;
29272 wxPoint temp3 ;
29273 wxSize temp4 ;
29274 long val5 ;
29275 int ecode5 = 0 ;
29276 bool temp6 = false ;
29277 PyObject * obj0 = 0 ;
29278 PyObject * obj1 = 0 ;
29279 PyObject * obj2 = 0 ;
29280 PyObject * obj3 = 0 ;
29281 PyObject * obj4 = 0 ;
29282 PyObject * obj5 = 0 ;
29283 char * kwnames[] = {
29284 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29285 };
29286
29287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29289 if (!SWIG_IsOK(res1)) {
29290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29291 }
29292 arg1 = reinterpret_cast< wxWindow * >(argp1);
29293 if (obj1) {
29294 ecode2 = SWIG_AsVal_int(obj1, &val2);
29295 if (!SWIG_IsOK(ecode2)) {
29296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29297 }
29298 arg2 = static_cast< int >(val2);
29299 }
29300 if (obj2) {
29301 {
29302 arg3 = &temp3;
29303 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29304 }
29305 }
29306 if (obj3) {
29307 {
29308 arg4 = &temp4;
29309 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29310 }
29311 }
29312 if (obj4) {
29313 ecode5 = SWIG_AsVal_long(obj4, &val5);
29314 if (!SWIG_IsOK(ecode5)) {
29315 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29316 }
29317 arg5 = static_cast< long >(val5);
29318 }
29319 if (obj5) {
29320 {
29321 arg6 = wxString_in_helper(obj5);
29322 if (arg6 == NULL) SWIG_fail;
29323 temp6 = true;
29324 }
29325 }
29326 {
29327 if (!wxPyCheckForApp()) SWIG_fail;
29328 PyThreadState* __tstate = wxPyBeginAllowThreads();
29329 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29330 wxPyEndAllowThreads(__tstate);
29331 if (PyErr_Occurred()) SWIG_fail;
29332 }
29333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29334 {
29335 if (temp6)
29336 delete arg6;
29337 }
29338 return resultobj;
29339 fail:
29340 {
29341 if (temp6)
29342 delete arg6;
29343 }
29344 return NULL;
29345 }
29346
29347
29348 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29349 PyObject *resultobj = 0;
29350 wxWindow *result = 0 ;
29351
29352 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29353 {
29354 if (!wxPyCheckForApp()) SWIG_fail;
29355 PyThreadState* __tstate = wxPyBeginAllowThreads();
29356 result = (wxWindow *)new wxWindow();
29357 wxPyEndAllowThreads(__tstate);
29358 if (PyErr_Occurred()) SWIG_fail;
29359 }
29360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29361 return resultobj;
29362 fail:
29363 return NULL;
29364 }
29365
29366
29367 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29368 PyObject *resultobj = 0;
29369 wxWindow *arg1 = (wxWindow *) 0 ;
29370 wxWindow *arg2 = (wxWindow *) 0 ;
29371 int arg3 = (int) (int)-1 ;
29372 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29373 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29374 wxSize const &arg5_defvalue = wxDefaultSize ;
29375 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29376 long arg6 = (long) 0 ;
29377 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29378 wxString *arg7 = (wxString *) &arg7_defvalue ;
29379 bool result;
29380 void *argp1 = 0 ;
29381 int res1 = 0 ;
29382 void *argp2 = 0 ;
29383 int res2 = 0 ;
29384 int val3 ;
29385 int ecode3 = 0 ;
29386 wxPoint temp4 ;
29387 wxSize temp5 ;
29388 long val6 ;
29389 int ecode6 = 0 ;
29390 bool temp7 = false ;
29391 PyObject * obj0 = 0 ;
29392 PyObject * obj1 = 0 ;
29393 PyObject * obj2 = 0 ;
29394 PyObject * obj3 = 0 ;
29395 PyObject * obj4 = 0 ;
29396 PyObject * obj5 = 0 ;
29397 PyObject * obj6 = 0 ;
29398 char * kwnames[] = {
29399 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29400 };
29401
29402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29404 if (!SWIG_IsOK(res1)) {
29405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29406 }
29407 arg1 = reinterpret_cast< wxWindow * >(argp1);
29408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29409 if (!SWIG_IsOK(res2)) {
29410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29411 }
29412 arg2 = reinterpret_cast< wxWindow * >(argp2);
29413 if (obj2) {
29414 ecode3 = SWIG_AsVal_int(obj2, &val3);
29415 if (!SWIG_IsOK(ecode3)) {
29416 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29417 }
29418 arg3 = static_cast< int >(val3);
29419 }
29420 if (obj3) {
29421 {
29422 arg4 = &temp4;
29423 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29424 }
29425 }
29426 if (obj4) {
29427 {
29428 arg5 = &temp5;
29429 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29430 }
29431 }
29432 if (obj5) {
29433 ecode6 = SWIG_AsVal_long(obj5, &val6);
29434 if (!SWIG_IsOK(ecode6)) {
29435 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29436 }
29437 arg6 = static_cast< long >(val6);
29438 }
29439 if (obj6) {
29440 {
29441 arg7 = wxString_in_helper(obj6);
29442 if (arg7 == NULL) SWIG_fail;
29443 temp7 = true;
29444 }
29445 }
29446 {
29447 PyThreadState* __tstate = wxPyBeginAllowThreads();
29448 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29449 wxPyEndAllowThreads(__tstate);
29450 if (PyErr_Occurred()) SWIG_fail;
29451 }
29452 {
29453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29454 }
29455 {
29456 if (temp7)
29457 delete arg7;
29458 }
29459 return resultobj;
29460 fail:
29461 {
29462 if (temp7)
29463 delete arg7;
29464 }
29465 return NULL;
29466 }
29467
29468
29469 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29470 PyObject *resultobj = 0;
29471 wxWindow *arg1 = (wxWindow *) 0 ;
29472 bool arg2 = (bool) false ;
29473 bool result;
29474 void *argp1 = 0 ;
29475 int res1 = 0 ;
29476 bool val2 ;
29477 int ecode2 = 0 ;
29478 PyObject * obj0 = 0 ;
29479 PyObject * obj1 = 0 ;
29480 char * kwnames[] = {
29481 (char *) "self",(char *) "force", NULL
29482 };
29483
29484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29486 if (!SWIG_IsOK(res1)) {
29487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29488 }
29489 arg1 = reinterpret_cast< wxWindow * >(argp1);
29490 if (obj1) {
29491 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29492 if (!SWIG_IsOK(ecode2)) {
29493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29494 }
29495 arg2 = static_cast< bool >(val2);
29496 }
29497 {
29498 PyThreadState* __tstate = wxPyBeginAllowThreads();
29499 result = (bool)(arg1)->Close(arg2);
29500 wxPyEndAllowThreads(__tstate);
29501 if (PyErr_Occurred()) SWIG_fail;
29502 }
29503 {
29504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29505 }
29506 return resultobj;
29507 fail:
29508 return NULL;
29509 }
29510
29511
29512 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29513 PyObject *resultobj = 0;
29514 wxWindow *arg1 = (wxWindow *) 0 ;
29515 bool result;
29516 void *argp1 = 0 ;
29517 int res1 = 0 ;
29518 PyObject *swig_obj[1] ;
29519
29520 if (!args) SWIG_fail;
29521 swig_obj[0] = args;
29522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29523 if (!SWIG_IsOK(res1)) {
29524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29525 }
29526 arg1 = reinterpret_cast< wxWindow * >(argp1);
29527 {
29528 PyThreadState* __tstate = wxPyBeginAllowThreads();
29529 result = (bool)(arg1)->Destroy();
29530 wxPyEndAllowThreads(__tstate);
29531 if (PyErr_Occurred()) SWIG_fail;
29532 }
29533 {
29534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29535 }
29536 return resultobj;
29537 fail:
29538 return NULL;
29539 }
29540
29541
29542 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29543 PyObject *resultobj = 0;
29544 wxWindow *arg1 = (wxWindow *) 0 ;
29545 bool result;
29546 void *argp1 = 0 ;
29547 int res1 = 0 ;
29548 PyObject *swig_obj[1] ;
29549
29550 if (!args) SWIG_fail;
29551 swig_obj[0] = args;
29552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29553 if (!SWIG_IsOK(res1)) {
29554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29555 }
29556 arg1 = reinterpret_cast< wxWindow * >(argp1);
29557 {
29558 PyThreadState* __tstate = wxPyBeginAllowThreads();
29559 result = (bool)(arg1)->DestroyChildren();
29560 wxPyEndAllowThreads(__tstate);
29561 if (PyErr_Occurred()) SWIG_fail;
29562 }
29563 {
29564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29565 }
29566 return resultobj;
29567 fail:
29568 return NULL;
29569 }
29570
29571
29572 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29573 PyObject *resultobj = 0;
29574 wxWindow *arg1 = (wxWindow *) 0 ;
29575 bool result;
29576 void *argp1 = 0 ;
29577 int res1 = 0 ;
29578 PyObject *swig_obj[1] ;
29579
29580 if (!args) SWIG_fail;
29581 swig_obj[0] = args;
29582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29583 if (!SWIG_IsOK(res1)) {
29584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29585 }
29586 arg1 = reinterpret_cast< wxWindow * >(argp1);
29587 {
29588 PyThreadState* __tstate = wxPyBeginAllowThreads();
29589 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29590 wxPyEndAllowThreads(__tstate);
29591 if (PyErr_Occurred()) SWIG_fail;
29592 }
29593 {
29594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29595 }
29596 return resultobj;
29597 fail:
29598 return NULL;
29599 }
29600
29601
29602 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29603 PyObject *resultobj = 0;
29604 wxWindow *arg1 = (wxWindow *) 0 ;
29605 wxString *arg2 = 0 ;
29606 void *argp1 = 0 ;
29607 int res1 = 0 ;
29608 bool temp2 = false ;
29609 PyObject * obj0 = 0 ;
29610 PyObject * obj1 = 0 ;
29611 char * kwnames[] = {
29612 (char *) "self",(char *) "label", NULL
29613 };
29614
29615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29617 if (!SWIG_IsOK(res1)) {
29618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29619 }
29620 arg1 = reinterpret_cast< wxWindow * >(argp1);
29621 {
29622 arg2 = wxString_in_helper(obj1);
29623 if (arg2 == NULL) SWIG_fail;
29624 temp2 = true;
29625 }
29626 {
29627 PyThreadState* __tstate = wxPyBeginAllowThreads();
29628 (arg1)->SetLabel((wxString const &)*arg2);
29629 wxPyEndAllowThreads(__tstate);
29630 if (PyErr_Occurred()) SWIG_fail;
29631 }
29632 resultobj = SWIG_Py_Void();
29633 {
29634 if (temp2)
29635 delete arg2;
29636 }
29637 return resultobj;
29638 fail:
29639 {
29640 if (temp2)
29641 delete arg2;
29642 }
29643 return NULL;
29644 }
29645
29646
29647 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29648 PyObject *resultobj = 0;
29649 wxWindow *arg1 = (wxWindow *) 0 ;
29650 wxString result;
29651 void *argp1 = 0 ;
29652 int res1 = 0 ;
29653 PyObject *swig_obj[1] ;
29654
29655 if (!args) SWIG_fail;
29656 swig_obj[0] = args;
29657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29658 if (!SWIG_IsOK(res1)) {
29659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29660 }
29661 arg1 = reinterpret_cast< wxWindow * >(argp1);
29662 {
29663 PyThreadState* __tstate = wxPyBeginAllowThreads();
29664 result = ((wxWindow const *)arg1)->GetLabel();
29665 wxPyEndAllowThreads(__tstate);
29666 if (PyErr_Occurred()) SWIG_fail;
29667 }
29668 {
29669 #if wxUSE_UNICODE
29670 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29671 #else
29672 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29673 #endif
29674 }
29675 return resultobj;
29676 fail:
29677 return NULL;
29678 }
29679
29680
29681 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29682 PyObject *resultobj = 0;
29683 wxWindow *arg1 = (wxWindow *) 0 ;
29684 wxString *arg2 = 0 ;
29685 void *argp1 = 0 ;
29686 int res1 = 0 ;
29687 bool temp2 = false ;
29688 PyObject * obj0 = 0 ;
29689 PyObject * obj1 = 0 ;
29690 char * kwnames[] = {
29691 (char *) "self",(char *) "name", NULL
29692 };
29693
29694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29696 if (!SWIG_IsOK(res1)) {
29697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29698 }
29699 arg1 = reinterpret_cast< wxWindow * >(argp1);
29700 {
29701 arg2 = wxString_in_helper(obj1);
29702 if (arg2 == NULL) SWIG_fail;
29703 temp2 = true;
29704 }
29705 {
29706 PyThreadState* __tstate = wxPyBeginAllowThreads();
29707 (arg1)->SetName((wxString const &)*arg2);
29708 wxPyEndAllowThreads(__tstate);
29709 if (PyErr_Occurred()) SWIG_fail;
29710 }
29711 resultobj = SWIG_Py_Void();
29712 {
29713 if (temp2)
29714 delete arg2;
29715 }
29716 return resultobj;
29717 fail:
29718 {
29719 if (temp2)
29720 delete arg2;
29721 }
29722 return NULL;
29723 }
29724
29725
29726 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29727 PyObject *resultobj = 0;
29728 wxWindow *arg1 = (wxWindow *) 0 ;
29729 wxString result;
29730 void *argp1 = 0 ;
29731 int res1 = 0 ;
29732 PyObject *swig_obj[1] ;
29733
29734 if (!args) SWIG_fail;
29735 swig_obj[0] = args;
29736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29737 if (!SWIG_IsOK(res1)) {
29738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29739 }
29740 arg1 = reinterpret_cast< wxWindow * >(argp1);
29741 {
29742 PyThreadState* __tstate = wxPyBeginAllowThreads();
29743 result = ((wxWindow const *)arg1)->GetName();
29744 wxPyEndAllowThreads(__tstate);
29745 if (PyErr_Occurred()) SWIG_fail;
29746 }
29747 {
29748 #if wxUSE_UNICODE
29749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29750 #else
29751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29752 #endif
29753 }
29754 return resultobj;
29755 fail:
29756 return NULL;
29757 }
29758
29759
29760 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29761 PyObject *resultobj = 0;
29762 wxWindow *arg1 = (wxWindow *) 0 ;
29763 wxWindowVariant arg2 ;
29764 void *argp1 = 0 ;
29765 int res1 = 0 ;
29766 int val2 ;
29767 int ecode2 = 0 ;
29768 PyObject * obj0 = 0 ;
29769 PyObject * obj1 = 0 ;
29770 char * kwnames[] = {
29771 (char *) "self",(char *) "variant", NULL
29772 };
29773
29774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29776 if (!SWIG_IsOK(res1)) {
29777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29778 }
29779 arg1 = reinterpret_cast< wxWindow * >(argp1);
29780 ecode2 = SWIG_AsVal_int(obj1, &val2);
29781 if (!SWIG_IsOK(ecode2)) {
29782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29783 }
29784 arg2 = static_cast< wxWindowVariant >(val2);
29785 {
29786 PyThreadState* __tstate = wxPyBeginAllowThreads();
29787 (arg1)->SetWindowVariant(arg2);
29788 wxPyEndAllowThreads(__tstate);
29789 if (PyErr_Occurred()) SWIG_fail;
29790 }
29791 resultobj = SWIG_Py_Void();
29792 return resultobj;
29793 fail:
29794 return NULL;
29795 }
29796
29797
29798 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29799 PyObject *resultobj = 0;
29800 wxWindow *arg1 = (wxWindow *) 0 ;
29801 wxWindowVariant result;
29802 void *argp1 = 0 ;
29803 int res1 = 0 ;
29804 PyObject *swig_obj[1] ;
29805
29806 if (!args) SWIG_fail;
29807 swig_obj[0] = args;
29808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29809 if (!SWIG_IsOK(res1)) {
29810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29811 }
29812 arg1 = reinterpret_cast< wxWindow * >(argp1);
29813 {
29814 PyThreadState* __tstate = wxPyBeginAllowThreads();
29815 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29816 wxPyEndAllowThreads(__tstate);
29817 if (PyErr_Occurred()) SWIG_fail;
29818 }
29819 resultobj = SWIG_From_int(static_cast< int >(result));
29820 return resultobj;
29821 fail:
29822 return NULL;
29823 }
29824
29825
29826 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29827 PyObject *resultobj = 0;
29828 wxWindow *arg1 = (wxWindow *) 0 ;
29829 int arg2 ;
29830 void *argp1 = 0 ;
29831 int res1 = 0 ;
29832 int val2 ;
29833 int ecode2 = 0 ;
29834 PyObject * obj0 = 0 ;
29835 PyObject * obj1 = 0 ;
29836 char * kwnames[] = {
29837 (char *) "self",(char *) "winid", NULL
29838 };
29839
29840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29842 if (!SWIG_IsOK(res1)) {
29843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29844 }
29845 arg1 = reinterpret_cast< wxWindow * >(argp1);
29846 ecode2 = SWIG_AsVal_int(obj1, &val2);
29847 if (!SWIG_IsOK(ecode2)) {
29848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29849 }
29850 arg2 = static_cast< int >(val2);
29851 {
29852 PyThreadState* __tstate = wxPyBeginAllowThreads();
29853 (arg1)->SetId(arg2);
29854 wxPyEndAllowThreads(__tstate);
29855 if (PyErr_Occurred()) SWIG_fail;
29856 }
29857 resultobj = SWIG_Py_Void();
29858 return resultobj;
29859 fail:
29860 return NULL;
29861 }
29862
29863
29864 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29865 PyObject *resultobj = 0;
29866 wxWindow *arg1 = (wxWindow *) 0 ;
29867 int result;
29868 void *argp1 = 0 ;
29869 int res1 = 0 ;
29870 PyObject *swig_obj[1] ;
29871
29872 if (!args) SWIG_fail;
29873 swig_obj[0] = args;
29874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29875 if (!SWIG_IsOK(res1)) {
29876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29877 }
29878 arg1 = reinterpret_cast< wxWindow * >(argp1);
29879 {
29880 PyThreadState* __tstate = wxPyBeginAllowThreads();
29881 result = (int)((wxWindow const *)arg1)->GetId();
29882 wxPyEndAllowThreads(__tstate);
29883 if (PyErr_Occurred()) SWIG_fail;
29884 }
29885 resultobj = SWIG_From_int(static_cast< int >(result));
29886 return resultobj;
29887 fail:
29888 return NULL;
29889 }
29890
29891
29892 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29893 PyObject *resultobj = 0;
29894 int result;
29895
29896 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
29897 {
29898 PyThreadState* __tstate = wxPyBeginAllowThreads();
29899 result = (int)wxWindow::NewControlId();
29900 wxPyEndAllowThreads(__tstate);
29901 if (PyErr_Occurred()) SWIG_fail;
29902 }
29903 resultobj = SWIG_From_int(static_cast< int >(result));
29904 return resultobj;
29905 fail:
29906 return NULL;
29907 }
29908
29909
29910 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29911 PyObject *resultobj = 0;
29912 int arg1 ;
29913 int result;
29914 int val1 ;
29915 int ecode1 = 0 ;
29916 PyObject * obj0 = 0 ;
29917 char * kwnames[] = {
29918 (char *) "winid", NULL
29919 };
29920
29921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
29922 ecode1 = SWIG_AsVal_int(obj0, &val1);
29923 if (!SWIG_IsOK(ecode1)) {
29924 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
29925 }
29926 arg1 = static_cast< int >(val1);
29927 {
29928 PyThreadState* __tstate = wxPyBeginAllowThreads();
29929 result = (int)wxWindow::NextControlId(arg1);
29930 wxPyEndAllowThreads(__tstate);
29931 if (PyErr_Occurred()) SWIG_fail;
29932 }
29933 resultobj = SWIG_From_int(static_cast< int >(result));
29934 return resultobj;
29935 fail:
29936 return NULL;
29937 }
29938
29939
29940 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29941 PyObject *resultobj = 0;
29942 int arg1 ;
29943 int result;
29944 int val1 ;
29945 int ecode1 = 0 ;
29946 PyObject * obj0 = 0 ;
29947 char * kwnames[] = {
29948 (char *) "winid", NULL
29949 };
29950
29951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
29952 ecode1 = SWIG_AsVal_int(obj0, &val1);
29953 if (!SWIG_IsOK(ecode1)) {
29954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
29955 }
29956 arg1 = static_cast< int >(val1);
29957 {
29958 PyThreadState* __tstate = wxPyBeginAllowThreads();
29959 result = (int)wxWindow::PrevControlId(arg1);
29960 wxPyEndAllowThreads(__tstate);
29961 if (PyErr_Occurred()) SWIG_fail;
29962 }
29963 resultobj = SWIG_From_int(static_cast< int >(result));
29964 return resultobj;
29965 fail:
29966 return NULL;
29967 }
29968
29969
29970 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29971 PyObject *resultobj = 0;
29972 wxWindow *arg1 = (wxWindow *) 0 ;
29973 wxSize *arg2 = 0 ;
29974 void *argp1 = 0 ;
29975 int res1 = 0 ;
29976 wxSize temp2 ;
29977 PyObject * obj0 = 0 ;
29978 PyObject * obj1 = 0 ;
29979 char * kwnames[] = {
29980 (char *) "self",(char *) "size", NULL
29981 };
29982
29983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
29984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29985 if (!SWIG_IsOK(res1)) {
29986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
29987 }
29988 arg1 = reinterpret_cast< wxWindow * >(argp1);
29989 {
29990 arg2 = &temp2;
29991 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29992 }
29993 {
29994 PyThreadState* __tstate = wxPyBeginAllowThreads();
29995 (arg1)->SetSize((wxSize const &)*arg2);
29996 wxPyEndAllowThreads(__tstate);
29997 if (PyErr_Occurred()) SWIG_fail;
29998 }
29999 resultobj = SWIG_Py_Void();
30000 return resultobj;
30001 fail:
30002 return NULL;
30003 }
30004
30005
30006 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30007 PyObject *resultobj = 0;
30008 wxWindow *arg1 = (wxWindow *) 0 ;
30009 int arg2 ;
30010 int arg3 ;
30011 int arg4 ;
30012 int arg5 ;
30013 int arg6 = (int) wxSIZE_AUTO ;
30014 void *argp1 = 0 ;
30015 int res1 = 0 ;
30016 int val2 ;
30017 int ecode2 = 0 ;
30018 int val3 ;
30019 int ecode3 = 0 ;
30020 int val4 ;
30021 int ecode4 = 0 ;
30022 int val5 ;
30023 int ecode5 = 0 ;
30024 int val6 ;
30025 int ecode6 = 0 ;
30026 PyObject * obj0 = 0 ;
30027 PyObject * obj1 = 0 ;
30028 PyObject * obj2 = 0 ;
30029 PyObject * obj3 = 0 ;
30030 PyObject * obj4 = 0 ;
30031 PyObject * obj5 = 0 ;
30032 char * kwnames[] = {
30033 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30034 };
30035
30036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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_SetDimensions" "', 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_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30045 }
30046 arg2 = static_cast< int >(val2);
30047 ecode3 = SWIG_AsVal_int(obj2, &val3);
30048 if (!SWIG_IsOK(ecode3)) {
30049 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30050 }
30051 arg3 = static_cast< int >(val3);
30052 ecode4 = SWIG_AsVal_int(obj3, &val4);
30053 if (!SWIG_IsOK(ecode4)) {
30054 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30055 }
30056 arg4 = static_cast< int >(val4);
30057 ecode5 = SWIG_AsVal_int(obj4, &val5);
30058 if (!SWIG_IsOK(ecode5)) {
30059 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30060 }
30061 arg5 = static_cast< int >(val5);
30062 if (obj5) {
30063 ecode6 = SWIG_AsVal_int(obj5, &val6);
30064 if (!SWIG_IsOK(ecode6)) {
30065 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30066 }
30067 arg6 = static_cast< int >(val6);
30068 }
30069 {
30070 PyThreadState* __tstate = wxPyBeginAllowThreads();
30071 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30072 wxPyEndAllowThreads(__tstate);
30073 if (PyErr_Occurred()) SWIG_fail;
30074 }
30075 resultobj = SWIG_Py_Void();
30076 return resultobj;
30077 fail:
30078 return NULL;
30079 }
30080
30081
30082 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30083 PyObject *resultobj = 0;
30084 wxWindow *arg1 = (wxWindow *) 0 ;
30085 wxRect *arg2 = 0 ;
30086 int arg3 = (int) wxSIZE_AUTO ;
30087 void *argp1 = 0 ;
30088 int res1 = 0 ;
30089 wxRect temp2 ;
30090 int val3 ;
30091 int ecode3 = 0 ;
30092 PyObject * obj0 = 0 ;
30093 PyObject * obj1 = 0 ;
30094 PyObject * obj2 = 0 ;
30095 char * kwnames[] = {
30096 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30097 };
30098
30099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30101 if (!SWIG_IsOK(res1)) {
30102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30103 }
30104 arg1 = reinterpret_cast< wxWindow * >(argp1);
30105 {
30106 arg2 = &temp2;
30107 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30108 }
30109 if (obj2) {
30110 ecode3 = SWIG_AsVal_int(obj2, &val3);
30111 if (!SWIG_IsOK(ecode3)) {
30112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30113 }
30114 arg3 = static_cast< int >(val3);
30115 }
30116 {
30117 PyThreadState* __tstate = wxPyBeginAllowThreads();
30118 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30119 wxPyEndAllowThreads(__tstate);
30120 if (PyErr_Occurred()) SWIG_fail;
30121 }
30122 resultobj = SWIG_Py_Void();
30123 return resultobj;
30124 fail:
30125 return NULL;
30126 }
30127
30128
30129 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30130 PyObject *resultobj = 0;
30131 wxWindow *arg1 = (wxWindow *) 0 ;
30132 int arg2 ;
30133 int arg3 ;
30134 void *argp1 = 0 ;
30135 int res1 = 0 ;
30136 int val2 ;
30137 int ecode2 = 0 ;
30138 int val3 ;
30139 int ecode3 = 0 ;
30140 PyObject * obj0 = 0 ;
30141 PyObject * obj1 = 0 ;
30142 PyObject * obj2 = 0 ;
30143 char * kwnames[] = {
30144 (char *) "self",(char *) "width",(char *) "height", NULL
30145 };
30146
30147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30149 if (!SWIG_IsOK(res1)) {
30150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30151 }
30152 arg1 = reinterpret_cast< wxWindow * >(argp1);
30153 ecode2 = SWIG_AsVal_int(obj1, &val2);
30154 if (!SWIG_IsOK(ecode2)) {
30155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30156 }
30157 arg2 = static_cast< int >(val2);
30158 ecode3 = SWIG_AsVal_int(obj2, &val3);
30159 if (!SWIG_IsOK(ecode3)) {
30160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30161 }
30162 arg3 = static_cast< int >(val3);
30163 {
30164 PyThreadState* __tstate = wxPyBeginAllowThreads();
30165 (arg1)->SetSize(arg2,arg3);
30166 wxPyEndAllowThreads(__tstate);
30167 if (PyErr_Occurred()) SWIG_fail;
30168 }
30169 resultobj = SWIG_Py_Void();
30170 return resultobj;
30171 fail:
30172 return NULL;
30173 }
30174
30175
30176 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30177 PyObject *resultobj = 0;
30178 wxWindow *arg1 = (wxWindow *) 0 ;
30179 wxPoint *arg2 = 0 ;
30180 int arg3 = (int) wxSIZE_USE_EXISTING ;
30181 void *argp1 = 0 ;
30182 int res1 = 0 ;
30183 wxPoint temp2 ;
30184 int val3 ;
30185 int ecode3 = 0 ;
30186 PyObject * obj0 = 0 ;
30187 PyObject * obj1 = 0 ;
30188 PyObject * obj2 = 0 ;
30189 char * kwnames[] = {
30190 (char *) "self",(char *) "pt",(char *) "flags", NULL
30191 };
30192
30193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30195 if (!SWIG_IsOK(res1)) {
30196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30197 }
30198 arg1 = reinterpret_cast< wxWindow * >(argp1);
30199 {
30200 arg2 = &temp2;
30201 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30202 }
30203 if (obj2) {
30204 ecode3 = SWIG_AsVal_int(obj2, &val3);
30205 if (!SWIG_IsOK(ecode3)) {
30206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30207 }
30208 arg3 = static_cast< int >(val3);
30209 }
30210 {
30211 PyThreadState* __tstate = wxPyBeginAllowThreads();
30212 (arg1)->Move((wxPoint const &)*arg2,arg3);
30213 wxPyEndAllowThreads(__tstate);
30214 if (PyErr_Occurred()) SWIG_fail;
30215 }
30216 resultobj = SWIG_Py_Void();
30217 return resultobj;
30218 fail:
30219 return NULL;
30220 }
30221
30222
30223 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30224 PyObject *resultobj = 0;
30225 wxWindow *arg1 = (wxWindow *) 0 ;
30226 int arg2 ;
30227 int arg3 ;
30228 int arg4 = (int) wxSIZE_USE_EXISTING ;
30229 void *argp1 = 0 ;
30230 int res1 = 0 ;
30231 int val2 ;
30232 int ecode2 = 0 ;
30233 int val3 ;
30234 int ecode3 = 0 ;
30235 int val4 ;
30236 int ecode4 = 0 ;
30237 PyObject * obj0 = 0 ;
30238 PyObject * obj1 = 0 ;
30239 PyObject * obj2 = 0 ;
30240 PyObject * obj3 = 0 ;
30241 char * kwnames[] = {
30242 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30243 };
30244
30245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30249 }
30250 arg1 = reinterpret_cast< wxWindow * >(argp1);
30251 ecode2 = SWIG_AsVal_int(obj1, &val2);
30252 if (!SWIG_IsOK(ecode2)) {
30253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30254 }
30255 arg2 = static_cast< int >(val2);
30256 ecode3 = SWIG_AsVal_int(obj2, &val3);
30257 if (!SWIG_IsOK(ecode3)) {
30258 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30259 }
30260 arg3 = static_cast< int >(val3);
30261 if (obj3) {
30262 ecode4 = SWIG_AsVal_int(obj3, &val4);
30263 if (!SWIG_IsOK(ecode4)) {
30264 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30265 }
30266 arg4 = static_cast< int >(val4);
30267 }
30268 {
30269 PyThreadState* __tstate = wxPyBeginAllowThreads();
30270 (arg1)->Move(arg2,arg3,arg4);
30271 wxPyEndAllowThreads(__tstate);
30272 if (PyErr_Occurred()) SWIG_fail;
30273 }
30274 resultobj = SWIG_Py_Void();
30275 return resultobj;
30276 fail:
30277 return NULL;
30278 }
30279
30280
30281 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30282 PyObject *resultobj = 0;
30283 wxWindow *arg1 = (wxWindow *) 0 ;
30284 wxSize const &arg2_defvalue = wxDefaultSize ;
30285 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30286 void *argp1 = 0 ;
30287 int res1 = 0 ;
30288 wxSize temp2 ;
30289 PyObject * obj0 = 0 ;
30290 PyObject * obj1 = 0 ;
30291 char * kwnames[] = {
30292 (char *) "self",(char *) "size", NULL
30293 };
30294
30295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30297 if (!SWIG_IsOK(res1)) {
30298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30299 }
30300 arg1 = reinterpret_cast< wxWindow * >(argp1);
30301 if (obj1) {
30302 {
30303 arg2 = &temp2;
30304 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30305 }
30306 }
30307 {
30308 PyThreadState* __tstate = wxPyBeginAllowThreads();
30309 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30310 wxPyEndAllowThreads(__tstate);
30311 if (PyErr_Occurred()) SWIG_fail;
30312 }
30313 resultobj = SWIG_Py_Void();
30314 return resultobj;
30315 fail:
30316 return NULL;
30317 }
30318
30319
30320 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30321 PyObject *resultobj = 0;
30322 wxWindow *arg1 = (wxWindow *) 0 ;
30323 void *argp1 = 0 ;
30324 int res1 = 0 ;
30325 PyObject *swig_obj[1] ;
30326
30327 if (!args) SWIG_fail;
30328 swig_obj[0] = args;
30329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30330 if (!SWIG_IsOK(res1)) {
30331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30332 }
30333 arg1 = reinterpret_cast< wxWindow * >(argp1);
30334 {
30335 PyThreadState* __tstate = wxPyBeginAllowThreads();
30336 (arg1)->Raise();
30337 wxPyEndAllowThreads(__tstate);
30338 if (PyErr_Occurred()) SWIG_fail;
30339 }
30340 resultobj = SWIG_Py_Void();
30341 return resultobj;
30342 fail:
30343 return NULL;
30344 }
30345
30346
30347 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30348 PyObject *resultobj = 0;
30349 wxWindow *arg1 = (wxWindow *) 0 ;
30350 void *argp1 = 0 ;
30351 int res1 = 0 ;
30352 PyObject *swig_obj[1] ;
30353
30354 if (!args) SWIG_fail;
30355 swig_obj[0] = args;
30356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30357 if (!SWIG_IsOK(res1)) {
30358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30359 }
30360 arg1 = reinterpret_cast< wxWindow * >(argp1);
30361 {
30362 PyThreadState* __tstate = wxPyBeginAllowThreads();
30363 (arg1)->Lower();
30364 wxPyEndAllowThreads(__tstate);
30365 if (PyErr_Occurred()) SWIG_fail;
30366 }
30367 resultobj = SWIG_Py_Void();
30368 return resultobj;
30369 fail:
30370 return NULL;
30371 }
30372
30373
30374 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30375 PyObject *resultobj = 0;
30376 wxWindow *arg1 = (wxWindow *) 0 ;
30377 wxSize *arg2 = 0 ;
30378 void *argp1 = 0 ;
30379 int res1 = 0 ;
30380 wxSize temp2 ;
30381 PyObject * obj0 = 0 ;
30382 PyObject * obj1 = 0 ;
30383 char * kwnames[] = {
30384 (char *) "self",(char *) "size", NULL
30385 };
30386
30387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30389 if (!SWIG_IsOK(res1)) {
30390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30391 }
30392 arg1 = reinterpret_cast< wxWindow * >(argp1);
30393 {
30394 arg2 = &temp2;
30395 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30396 }
30397 {
30398 PyThreadState* __tstate = wxPyBeginAllowThreads();
30399 (arg1)->SetClientSize((wxSize const &)*arg2);
30400 wxPyEndAllowThreads(__tstate);
30401 if (PyErr_Occurred()) SWIG_fail;
30402 }
30403 resultobj = SWIG_Py_Void();
30404 return resultobj;
30405 fail:
30406 return NULL;
30407 }
30408
30409
30410 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30411 PyObject *resultobj = 0;
30412 wxWindow *arg1 = (wxWindow *) 0 ;
30413 int arg2 ;
30414 int arg3 ;
30415 void *argp1 = 0 ;
30416 int res1 = 0 ;
30417 int val2 ;
30418 int ecode2 = 0 ;
30419 int val3 ;
30420 int ecode3 = 0 ;
30421 PyObject * obj0 = 0 ;
30422 PyObject * obj1 = 0 ;
30423 PyObject * obj2 = 0 ;
30424 char * kwnames[] = {
30425 (char *) "self",(char *) "width",(char *) "height", NULL
30426 };
30427
30428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30430 if (!SWIG_IsOK(res1)) {
30431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30432 }
30433 arg1 = reinterpret_cast< wxWindow * >(argp1);
30434 ecode2 = SWIG_AsVal_int(obj1, &val2);
30435 if (!SWIG_IsOK(ecode2)) {
30436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30437 }
30438 arg2 = static_cast< int >(val2);
30439 ecode3 = SWIG_AsVal_int(obj2, &val3);
30440 if (!SWIG_IsOK(ecode3)) {
30441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30442 }
30443 arg3 = static_cast< int >(val3);
30444 {
30445 PyThreadState* __tstate = wxPyBeginAllowThreads();
30446 (arg1)->SetClientSize(arg2,arg3);
30447 wxPyEndAllowThreads(__tstate);
30448 if (PyErr_Occurred()) SWIG_fail;
30449 }
30450 resultobj = SWIG_Py_Void();
30451 return resultobj;
30452 fail:
30453 return NULL;
30454 }
30455
30456
30457 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30458 PyObject *resultobj = 0;
30459 wxWindow *arg1 = (wxWindow *) 0 ;
30460 wxRect *arg2 = 0 ;
30461 void *argp1 = 0 ;
30462 int res1 = 0 ;
30463 wxRect temp2 ;
30464 PyObject * obj0 = 0 ;
30465 PyObject * obj1 = 0 ;
30466 char * kwnames[] = {
30467 (char *) "self",(char *) "rect", NULL
30468 };
30469
30470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30472 if (!SWIG_IsOK(res1)) {
30473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30474 }
30475 arg1 = reinterpret_cast< wxWindow * >(argp1);
30476 {
30477 arg2 = &temp2;
30478 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30479 }
30480 {
30481 PyThreadState* __tstate = wxPyBeginAllowThreads();
30482 (arg1)->SetClientSize((wxRect const &)*arg2);
30483 wxPyEndAllowThreads(__tstate);
30484 if (PyErr_Occurred()) SWIG_fail;
30485 }
30486 resultobj = SWIG_Py_Void();
30487 return resultobj;
30488 fail:
30489 return NULL;
30490 }
30491
30492
30493 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30494 PyObject *resultobj = 0;
30495 wxWindow *arg1 = (wxWindow *) 0 ;
30496 wxPoint result;
30497 void *argp1 = 0 ;
30498 int res1 = 0 ;
30499 PyObject *swig_obj[1] ;
30500
30501 if (!args) SWIG_fail;
30502 swig_obj[0] = args;
30503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30504 if (!SWIG_IsOK(res1)) {
30505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow *""'");
30506 }
30507 arg1 = reinterpret_cast< wxWindow * >(argp1);
30508 {
30509 PyThreadState* __tstate = wxPyBeginAllowThreads();
30510 result = (arg1)->GetPosition();
30511 wxPyEndAllowThreads(__tstate);
30512 if (PyErr_Occurred()) SWIG_fail;
30513 }
30514 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30515 return resultobj;
30516 fail:
30517 return NULL;
30518 }
30519
30520
30521 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30522 PyObject *resultobj = 0;
30523 wxWindow *arg1 = (wxWindow *) 0 ;
30524 int *arg2 = (int *) 0 ;
30525 int *arg3 = (int *) 0 ;
30526 void *argp1 = 0 ;
30527 int res1 = 0 ;
30528 int temp2 ;
30529 int res2 = SWIG_TMPOBJ ;
30530 int temp3 ;
30531 int res3 = SWIG_TMPOBJ ;
30532 PyObject *swig_obj[1] ;
30533
30534 arg2 = &temp2;
30535 arg3 = &temp3;
30536 if (!args) SWIG_fail;
30537 swig_obj[0] = args;
30538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30539 if (!SWIG_IsOK(res1)) {
30540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow *""'");
30541 }
30542 arg1 = reinterpret_cast< wxWindow * >(argp1);
30543 {
30544 PyThreadState* __tstate = wxPyBeginAllowThreads();
30545 (arg1)->GetPosition(arg2,arg3);
30546 wxPyEndAllowThreads(__tstate);
30547 if (PyErr_Occurred()) SWIG_fail;
30548 }
30549 resultobj = SWIG_Py_Void();
30550 if (SWIG_IsTmpObj(res2)) {
30551 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30552 } else {
30553 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30554 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30555 }
30556 if (SWIG_IsTmpObj(res3)) {
30557 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30558 } else {
30559 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30560 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30561 }
30562 return resultobj;
30563 fail:
30564 return NULL;
30565 }
30566
30567
30568 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30569 PyObject *resultobj = 0;
30570 wxWindow *arg1 = (wxWindow *) 0 ;
30571 wxSize result;
30572 void *argp1 = 0 ;
30573 int res1 = 0 ;
30574 PyObject *swig_obj[1] ;
30575
30576 if (!args) SWIG_fail;
30577 swig_obj[0] = args;
30578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30579 if (!SWIG_IsOK(res1)) {
30580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30581 }
30582 arg1 = reinterpret_cast< wxWindow * >(argp1);
30583 {
30584 PyThreadState* __tstate = wxPyBeginAllowThreads();
30585 result = ((wxWindow const *)arg1)->GetSize();
30586 wxPyEndAllowThreads(__tstate);
30587 if (PyErr_Occurred()) SWIG_fail;
30588 }
30589 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30590 return resultobj;
30591 fail:
30592 return NULL;
30593 }
30594
30595
30596 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30597 PyObject *resultobj = 0;
30598 wxWindow *arg1 = (wxWindow *) 0 ;
30599 int *arg2 = (int *) 0 ;
30600 int *arg3 = (int *) 0 ;
30601 void *argp1 = 0 ;
30602 int res1 = 0 ;
30603 int temp2 ;
30604 int res2 = SWIG_TMPOBJ ;
30605 int temp3 ;
30606 int res3 = SWIG_TMPOBJ ;
30607 PyObject *swig_obj[1] ;
30608
30609 arg2 = &temp2;
30610 arg3 = &temp3;
30611 if (!args) SWIG_fail;
30612 swig_obj[0] = args;
30613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30614 if (!SWIG_IsOK(res1)) {
30615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30616 }
30617 arg1 = reinterpret_cast< wxWindow * >(argp1);
30618 {
30619 PyThreadState* __tstate = wxPyBeginAllowThreads();
30620 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30621 wxPyEndAllowThreads(__tstate);
30622 if (PyErr_Occurred()) SWIG_fail;
30623 }
30624 resultobj = SWIG_Py_Void();
30625 if (SWIG_IsTmpObj(res2)) {
30626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30627 } else {
30628 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30630 }
30631 if (SWIG_IsTmpObj(res3)) {
30632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30633 } else {
30634 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30636 }
30637 return resultobj;
30638 fail:
30639 return NULL;
30640 }
30641
30642
30643 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30644 PyObject *resultobj = 0;
30645 wxWindow *arg1 = (wxWindow *) 0 ;
30646 wxRect result;
30647 void *argp1 = 0 ;
30648 int res1 = 0 ;
30649 PyObject *swig_obj[1] ;
30650
30651 if (!args) SWIG_fail;
30652 swig_obj[0] = args;
30653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30654 if (!SWIG_IsOK(res1)) {
30655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30656 }
30657 arg1 = reinterpret_cast< wxWindow * >(argp1);
30658 {
30659 PyThreadState* __tstate = wxPyBeginAllowThreads();
30660 result = ((wxWindow const *)arg1)->GetRect();
30661 wxPyEndAllowThreads(__tstate);
30662 if (PyErr_Occurred()) SWIG_fail;
30663 }
30664 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30665 return resultobj;
30666 fail:
30667 return NULL;
30668 }
30669
30670
30671 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30672 PyObject *resultobj = 0;
30673 wxWindow *arg1 = (wxWindow *) 0 ;
30674 wxSize result;
30675 void *argp1 = 0 ;
30676 int res1 = 0 ;
30677 PyObject *swig_obj[1] ;
30678
30679 if (!args) SWIG_fail;
30680 swig_obj[0] = args;
30681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30682 if (!SWIG_IsOK(res1)) {
30683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30684 }
30685 arg1 = reinterpret_cast< wxWindow * >(argp1);
30686 {
30687 PyThreadState* __tstate = wxPyBeginAllowThreads();
30688 result = ((wxWindow const *)arg1)->GetClientSize();
30689 wxPyEndAllowThreads(__tstate);
30690 if (PyErr_Occurred()) SWIG_fail;
30691 }
30692 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30693 return resultobj;
30694 fail:
30695 return NULL;
30696 }
30697
30698
30699 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30700 PyObject *resultobj = 0;
30701 wxWindow *arg1 = (wxWindow *) 0 ;
30702 int *arg2 = (int *) 0 ;
30703 int *arg3 = (int *) 0 ;
30704 void *argp1 = 0 ;
30705 int res1 = 0 ;
30706 int temp2 ;
30707 int res2 = SWIG_TMPOBJ ;
30708 int temp3 ;
30709 int res3 = SWIG_TMPOBJ ;
30710 PyObject *swig_obj[1] ;
30711
30712 arg2 = &temp2;
30713 arg3 = &temp3;
30714 if (!args) SWIG_fail;
30715 swig_obj[0] = args;
30716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30717 if (!SWIG_IsOK(res1)) {
30718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30719 }
30720 arg1 = reinterpret_cast< wxWindow * >(argp1);
30721 {
30722 PyThreadState* __tstate = wxPyBeginAllowThreads();
30723 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30724 wxPyEndAllowThreads(__tstate);
30725 if (PyErr_Occurred()) SWIG_fail;
30726 }
30727 resultobj = SWIG_Py_Void();
30728 if (SWIG_IsTmpObj(res2)) {
30729 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30730 } else {
30731 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30733 }
30734 if (SWIG_IsTmpObj(res3)) {
30735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30736 } else {
30737 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30739 }
30740 return resultobj;
30741 fail:
30742 return NULL;
30743 }
30744
30745
30746 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30747 PyObject *resultobj = 0;
30748 wxWindow *arg1 = (wxWindow *) 0 ;
30749 wxPoint result;
30750 void *argp1 = 0 ;
30751 int res1 = 0 ;
30752 PyObject *swig_obj[1] ;
30753
30754 if (!args) SWIG_fail;
30755 swig_obj[0] = args;
30756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30757 if (!SWIG_IsOK(res1)) {
30758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30759 }
30760 arg1 = reinterpret_cast< wxWindow * >(argp1);
30761 {
30762 PyThreadState* __tstate = wxPyBeginAllowThreads();
30763 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30764 wxPyEndAllowThreads(__tstate);
30765 if (PyErr_Occurred()) SWIG_fail;
30766 }
30767 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30768 return resultobj;
30769 fail:
30770 return NULL;
30771 }
30772
30773
30774 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30775 PyObject *resultobj = 0;
30776 wxWindow *arg1 = (wxWindow *) 0 ;
30777 wxRect result;
30778 void *argp1 = 0 ;
30779 int res1 = 0 ;
30780 PyObject *swig_obj[1] ;
30781
30782 if (!args) SWIG_fail;
30783 swig_obj[0] = args;
30784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30785 if (!SWIG_IsOK(res1)) {
30786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30787 }
30788 arg1 = reinterpret_cast< wxWindow * >(argp1);
30789 {
30790 PyThreadState* __tstate = wxPyBeginAllowThreads();
30791 result = ((wxWindow const *)arg1)->GetClientRect();
30792 wxPyEndAllowThreads(__tstate);
30793 if (PyErr_Occurred()) SWIG_fail;
30794 }
30795 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30796 return resultobj;
30797 fail:
30798 return NULL;
30799 }
30800
30801
30802 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30803 PyObject *resultobj = 0;
30804 wxWindow *arg1 = (wxWindow *) 0 ;
30805 wxSize result;
30806 void *argp1 = 0 ;
30807 int res1 = 0 ;
30808 PyObject *swig_obj[1] ;
30809
30810 if (!args) SWIG_fail;
30811 swig_obj[0] = args;
30812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30813 if (!SWIG_IsOK(res1)) {
30814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30815 }
30816 arg1 = reinterpret_cast< wxWindow * >(argp1);
30817 {
30818 PyThreadState* __tstate = wxPyBeginAllowThreads();
30819 result = ((wxWindow const *)arg1)->GetBestSize();
30820 wxPyEndAllowThreads(__tstate);
30821 if (PyErr_Occurred()) SWIG_fail;
30822 }
30823 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30824 return resultobj;
30825 fail:
30826 return NULL;
30827 }
30828
30829
30830 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30831 PyObject *resultobj = 0;
30832 wxWindow *arg1 = (wxWindow *) 0 ;
30833 int *arg2 = (int *) 0 ;
30834 int *arg3 = (int *) 0 ;
30835 void *argp1 = 0 ;
30836 int res1 = 0 ;
30837 int temp2 ;
30838 int res2 = SWIG_TMPOBJ ;
30839 int temp3 ;
30840 int res3 = SWIG_TMPOBJ ;
30841 PyObject *swig_obj[1] ;
30842
30843 arg2 = &temp2;
30844 arg3 = &temp3;
30845 if (!args) SWIG_fail;
30846 swig_obj[0] = args;
30847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30848 if (!SWIG_IsOK(res1)) {
30849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30850 }
30851 arg1 = reinterpret_cast< wxWindow * >(argp1);
30852 {
30853 PyThreadState* __tstate = wxPyBeginAllowThreads();
30854 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
30855 wxPyEndAllowThreads(__tstate);
30856 if (PyErr_Occurred()) SWIG_fail;
30857 }
30858 resultobj = SWIG_Py_Void();
30859 if (SWIG_IsTmpObj(res2)) {
30860 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30861 } else {
30862 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30863 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30864 }
30865 if (SWIG_IsTmpObj(res3)) {
30866 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30867 } else {
30868 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30869 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30870 }
30871 return resultobj;
30872 fail:
30873 return NULL;
30874 }
30875
30876
30877 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30878 PyObject *resultobj = 0;
30879 wxWindow *arg1 = (wxWindow *) 0 ;
30880 void *argp1 = 0 ;
30881 int res1 = 0 ;
30882 PyObject *swig_obj[1] ;
30883
30884 if (!args) SWIG_fail;
30885 swig_obj[0] = args;
30886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30887 if (!SWIG_IsOK(res1)) {
30888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30889 }
30890 arg1 = reinterpret_cast< wxWindow * >(argp1);
30891 {
30892 PyThreadState* __tstate = wxPyBeginAllowThreads();
30893 (arg1)->InvalidateBestSize();
30894 wxPyEndAllowThreads(__tstate);
30895 if (PyErr_Occurred()) SWIG_fail;
30896 }
30897 resultobj = SWIG_Py_Void();
30898 return resultobj;
30899 fail:
30900 return NULL;
30901 }
30902
30903
30904 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30905 PyObject *resultobj = 0;
30906 wxWindow *arg1 = (wxWindow *) 0 ;
30907 wxSize *arg2 = 0 ;
30908 void *argp1 = 0 ;
30909 int res1 = 0 ;
30910 wxSize temp2 ;
30911 PyObject * obj0 = 0 ;
30912 PyObject * obj1 = 0 ;
30913 char * kwnames[] = {
30914 (char *) "self",(char *) "size", NULL
30915 };
30916
30917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
30918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30919 if (!SWIG_IsOK(res1)) {
30920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30921 }
30922 arg1 = reinterpret_cast< wxWindow * >(argp1);
30923 {
30924 arg2 = &temp2;
30925 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30926 }
30927 {
30928 PyThreadState* __tstate = wxPyBeginAllowThreads();
30929 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
30930 wxPyEndAllowThreads(__tstate);
30931 if (PyErr_Occurred()) SWIG_fail;
30932 }
30933 resultobj = SWIG_Py_Void();
30934 return resultobj;
30935 fail:
30936 return NULL;
30937 }
30938
30939
30940 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30941 PyObject *resultobj = 0;
30942 wxWindow *arg1 = (wxWindow *) 0 ;
30943 wxSize result;
30944 void *argp1 = 0 ;
30945 int res1 = 0 ;
30946 PyObject *swig_obj[1] ;
30947
30948 if (!args) SWIG_fail;
30949 swig_obj[0] = args;
30950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30951 if (!SWIG_IsOK(res1)) {
30952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30953 }
30954 arg1 = reinterpret_cast< wxWindow * >(argp1);
30955 {
30956 PyThreadState* __tstate = wxPyBeginAllowThreads();
30957 result = ((wxWindow const *)arg1)->GetBestFittingSize();
30958 wxPyEndAllowThreads(__tstate);
30959 if (PyErr_Occurred()) SWIG_fail;
30960 }
30961 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30962 return resultobj;
30963 fail:
30964 return NULL;
30965 }
30966
30967
30968 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30969 PyObject *resultobj = 0;
30970 wxWindow *arg1 = (wxWindow *) 0 ;
30971 wxSize result;
30972 void *argp1 = 0 ;
30973 int res1 = 0 ;
30974 PyObject *swig_obj[1] ;
30975
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_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30981 }
30982 arg1 = reinterpret_cast< wxWindow * >(argp1);
30983 {
30984 PyThreadState* __tstate = wxPyBeginAllowThreads();
30985 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
30986 wxPyEndAllowThreads(__tstate);
30987 if (PyErr_Occurred()) SWIG_fail;
30988 }
30989 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30990 return resultobj;
30991 fail:
30992 return NULL;
30993 }
30994
30995
30996 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30997 PyObject *resultobj = 0;
30998 wxWindow *arg1 = (wxWindow *) 0 ;
30999 int arg2 = (int) wxBOTH ;
31000 void *argp1 = 0 ;
31001 int res1 = 0 ;
31002 int val2 ;
31003 int ecode2 = 0 ;
31004 PyObject * obj0 = 0 ;
31005 PyObject * obj1 = 0 ;
31006 char * kwnames[] = {
31007 (char *) "self",(char *) "direction", NULL
31008 };
31009
31010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31012 if (!SWIG_IsOK(res1)) {
31013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31014 }
31015 arg1 = reinterpret_cast< wxWindow * >(argp1);
31016 if (obj1) {
31017 ecode2 = SWIG_AsVal_int(obj1, &val2);
31018 if (!SWIG_IsOK(ecode2)) {
31019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31020 }
31021 arg2 = static_cast< int >(val2);
31022 }
31023 {
31024 PyThreadState* __tstate = wxPyBeginAllowThreads();
31025 (arg1)->Center(arg2);
31026 wxPyEndAllowThreads(__tstate);
31027 if (PyErr_Occurred()) SWIG_fail;
31028 }
31029 resultobj = SWIG_Py_Void();
31030 return resultobj;
31031 fail:
31032 return NULL;
31033 }
31034
31035
31036 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31037 PyObject *resultobj = 0;
31038 wxWindow *arg1 = (wxWindow *) 0 ;
31039 int arg2 = (int) wxBOTH ;
31040 void *argp1 = 0 ;
31041 int res1 = 0 ;
31042 int val2 ;
31043 int ecode2 = 0 ;
31044 PyObject * obj0 = 0 ;
31045 PyObject * obj1 = 0 ;
31046 char * kwnames[] = {
31047 (char *) "self",(char *) "dir", NULL
31048 };
31049
31050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31052 if (!SWIG_IsOK(res1)) {
31053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31054 }
31055 arg1 = reinterpret_cast< wxWindow * >(argp1);
31056 if (obj1) {
31057 ecode2 = SWIG_AsVal_int(obj1, &val2);
31058 if (!SWIG_IsOK(ecode2)) {
31059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31060 }
31061 arg2 = static_cast< int >(val2);
31062 }
31063 {
31064 PyThreadState* __tstate = wxPyBeginAllowThreads();
31065 (arg1)->CenterOnParent(arg2);
31066 wxPyEndAllowThreads(__tstate);
31067 if (PyErr_Occurred()) SWIG_fail;
31068 }
31069 resultobj = SWIG_Py_Void();
31070 return resultobj;
31071 fail:
31072 return NULL;
31073 }
31074
31075
31076 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31077 PyObject *resultobj = 0;
31078 wxWindow *arg1 = (wxWindow *) 0 ;
31079 void *argp1 = 0 ;
31080 int res1 = 0 ;
31081 PyObject *swig_obj[1] ;
31082
31083 if (!args) SWIG_fail;
31084 swig_obj[0] = args;
31085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31086 if (!SWIG_IsOK(res1)) {
31087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31088 }
31089 arg1 = reinterpret_cast< wxWindow * >(argp1);
31090 {
31091 PyThreadState* __tstate = wxPyBeginAllowThreads();
31092 (arg1)->Fit();
31093 wxPyEndAllowThreads(__tstate);
31094 if (PyErr_Occurred()) SWIG_fail;
31095 }
31096 resultobj = SWIG_Py_Void();
31097 return resultobj;
31098 fail:
31099 return NULL;
31100 }
31101
31102
31103 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31104 PyObject *resultobj = 0;
31105 wxWindow *arg1 = (wxWindow *) 0 ;
31106 void *argp1 = 0 ;
31107 int res1 = 0 ;
31108 PyObject *swig_obj[1] ;
31109
31110 if (!args) SWIG_fail;
31111 swig_obj[0] = args;
31112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31113 if (!SWIG_IsOK(res1)) {
31114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31115 }
31116 arg1 = reinterpret_cast< wxWindow * >(argp1);
31117 {
31118 PyThreadState* __tstate = wxPyBeginAllowThreads();
31119 (arg1)->FitInside();
31120 wxPyEndAllowThreads(__tstate);
31121 if (PyErr_Occurred()) SWIG_fail;
31122 }
31123 resultobj = SWIG_Py_Void();
31124 return resultobj;
31125 fail:
31126 return NULL;
31127 }
31128
31129
31130 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31131 PyObject *resultobj = 0;
31132 wxWindow *arg1 = (wxWindow *) 0 ;
31133 int arg2 ;
31134 int arg3 ;
31135 int arg4 = (int) -1 ;
31136 int arg5 = (int) -1 ;
31137 int arg6 = (int) -1 ;
31138 int arg7 = (int) -1 ;
31139 void *argp1 = 0 ;
31140 int res1 = 0 ;
31141 int val2 ;
31142 int ecode2 = 0 ;
31143 int val3 ;
31144 int ecode3 = 0 ;
31145 int val4 ;
31146 int ecode4 = 0 ;
31147 int val5 ;
31148 int ecode5 = 0 ;
31149 int val6 ;
31150 int ecode6 = 0 ;
31151 int val7 ;
31152 int ecode7 = 0 ;
31153 PyObject * obj0 = 0 ;
31154 PyObject * obj1 = 0 ;
31155 PyObject * obj2 = 0 ;
31156 PyObject * obj3 = 0 ;
31157 PyObject * obj4 = 0 ;
31158 PyObject * obj5 = 0 ;
31159 PyObject * obj6 = 0 ;
31160 char * kwnames[] = {
31161 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31162 };
31163
31164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31166 if (!SWIG_IsOK(res1)) {
31167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31168 }
31169 arg1 = reinterpret_cast< wxWindow * >(argp1);
31170 ecode2 = SWIG_AsVal_int(obj1, &val2);
31171 if (!SWIG_IsOK(ecode2)) {
31172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31173 }
31174 arg2 = static_cast< int >(val2);
31175 ecode3 = SWIG_AsVal_int(obj2, &val3);
31176 if (!SWIG_IsOK(ecode3)) {
31177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31178 }
31179 arg3 = static_cast< int >(val3);
31180 if (obj3) {
31181 ecode4 = SWIG_AsVal_int(obj3, &val4);
31182 if (!SWIG_IsOK(ecode4)) {
31183 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31184 }
31185 arg4 = static_cast< int >(val4);
31186 }
31187 if (obj4) {
31188 ecode5 = SWIG_AsVal_int(obj4, &val5);
31189 if (!SWIG_IsOK(ecode5)) {
31190 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31191 }
31192 arg5 = static_cast< int >(val5);
31193 }
31194 if (obj5) {
31195 ecode6 = SWIG_AsVal_int(obj5, &val6);
31196 if (!SWIG_IsOK(ecode6)) {
31197 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31198 }
31199 arg6 = static_cast< int >(val6);
31200 }
31201 if (obj6) {
31202 ecode7 = SWIG_AsVal_int(obj6, &val7);
31203 if (!SWIG_IsOK(ecode7)) {
31204 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31205 }
31206 arg7 = static_cast< int >(val7);
31207 }
31208 {
31209 PyThreadState* __tstate = wxPyBeginAllowThreads();
31210 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31211 wxPyEndAllowThreads(__tstate);
31212 if (PyErr_Occurred()) SWIG_fail;
31213 }
31214 resultobj = SWIG_Py_Void();
31215 return resultobj;
31216 fail:
31217 return NULL;
31218 }
31219
31220
31221 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31222 PyObject *resultobj = 0;
31223 wxWindow *arg1 = (wxWindow *) 0 ;
31224 wxSize *arg2 = 0 ;
31225 wxSize const &arg3_defvalue = wxDefaultSize ;
31226 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31227 wxSize const &arg4_defvalue = wxDefaultSize ;
31228 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31229 void *argp1 = 0 ;
31230 int res1 = 0 ;
31231 wxSize temp2 ;
31232 wxSize temp3 ;
31233 wxSize temp4 ;
31234 PyObject * obj0 = 0 ;
31235 PyObject * obj1 = 0 ;
31236 PyObject * obj2 = 0 ;
31237 PyObject * obj3 = 0 ;
31238 char * kwnames[] = {
31239 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31240 };
31241
31242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31244 if (!SWIG_IsOK(res1)) {
31245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31246 }
31247 arg1 = reinterpret_cast< wxWindow * >(argp1);
31248 {
31249 arg2 = &temp2;
31250 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31251 }
31252 if (obj2) {
31253 {
31254 arg3 = &temp3;
31255 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31256 }
31257 }
31258 if (obj3) {
31259 {
31260 arg4 = &temp4;
31261 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31262 }
31263 }
31264 {
31265 PyThreadState* __tstate = wxPyBeginAllowThreads();
31266 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31267 wxPyEndAllowThreads(__tstate);
31268 if (PyErr_Occurred()) SWIG_fail;
31269 }
31270 resultobj = SWIG_Py_Void();
31271 return resultobj;
31272 fail:
31273 return NULL;
31274 }
31275
31276
31277 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31278 PyObject *resultobj = 0;
31279 wxWindow *arg1 = (wxWindow *) 0 ;
31280 int arg2 ;
31281 int arg3 ;
31282 int arg4 = (int) -1 ;
31283 int arg5 = (int) -1 ;
31284 void *argp1 = 0 ;
31285 int res1 = 0 ;
31286 int val2 ;
31287 int ecode2 = 0 ;
31288 int val3 ;
31289 int ecode3 = 0 ;
31290 int val4 ;
31291 int ecode4 = 0 ;
31292 int val5 ;
31293 int ecode5 = 0 ;
31294 PyObject * obj0 = 0 ;
31295 PyObject * obj1 = 0 ;
31296 PyObject * obj2 = 0 ;
31297 PyObject * obj3 = 0 ;
31298 PyObject * obj4 = 0 ;
31299 char * kwnames[] = {
31300 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31301 };
31302
31303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31305 if (!SWIG_IsOK(res1)) {
31306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31307 }
31308 arg1 = reinterpret_cast< wxWindow * >(argp1);
31309 ecode2 = SWIG_AsVal_int(obj1, &val2);
31310 if (!SWIG_IsOK(ecode2)) {
31311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31312 }
31313 arg2 = static_cast< int >(val2);
31314 ecode3 = SWIG_AsVal_int(obj2, &val3);
31315 if (!SWIG_IsOK(ecode3)) {
31316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31317 }
31318 arg3 = static_cast< int >(val3);
31319 if (obj3) {
31320 ecode4 = SWIG_AsVal_int(obj3, &val4);
31321 if (!SWIG_IsOK(ecode4)) {
31322 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31323 }
31324 arg4 = static_cast< int >(val4);
31325 }
31326 if (obj4) {
31327 ecode5 = SWIG_AsVal_int(obj4, &val5);
31328 if (!SWIG_IsOK(ecode5)) {
31329 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31330 }
31331 arg5 = static_cast< int >(val5);
31332 }
31333 {
31334 PyThreadState* __tstate = wxPyBeginAllowThreads();
31335 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31336 wxPyEndAllowThreads(__tstate);
31337 if (PyErr_Occurred()) SWIG_fail;
31338 }
31339 resultobj = SWIG_Py_Void();
31340 return resultobj;
31341 fail:
31342 return NULL;
31343 }
31344
31345
31346 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31347 PyObject *resultobj = 0;
31348 wxWindow *arg1 = (wxWindow *) 0 ;
31349 wxSize *arg2 = 0 ;
31350 wxSize const &arg3_defvalue = wxDefaultSize ;
31351 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31352 void *argp1 = 0 ;
31353 int res1 = 0 ;
31354 wxSize temp2 ;
31355 wxSize temp3 ;
31356 PyObject * obj0 = 0 ;
31357 PyObject * obj1 = 0 ;
31358 PyObject * obj2 = 0 ;
31359 char * kwnames[] = {
31360 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31361 };
31362
31363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31365 if (!SWIG_IsOK(res1)) {
31366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31367 }
31368 arg1 = reinterpret_cast< wxWindow * >(argp1);
31369 {
31370 arg2 = &temp2;
31371 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31372 }
31373 if (obj2) {
31374 {
31375 arg3 = &temp3;
31376 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31377 }
31378 }
31379 {
31380 PyThreadState* __tstate = wxPyBeginAllowThreads();
31381 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31382 wxPyEndAllowThreads(__tstate);
31383 if (PyErr_Occurred()) SWIG_fail;
31384 }
31385 resultobj = SWIG_Py_Void();
31386 return resultobj;
31387 fail:
31388 return NULL;
31389 }
31390
31391
31392 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31393 PyObject *resultobj = 0;
31394 wxWindow *arg1 = (wxWindow *) 0 ;
31395 wxSize result;
31396 void *argp1 = 0 ;
31397 int res1 = 0 ;
31398 PyObject *swig_obj[1] ;
31399
31400 if (!args) SWIG_fail;
31401 swig_obj[0] = args;
31402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31403 if (!SWIG_IsOK(res1)) {
31404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31405 }
31406 arg1 = reinterpret_cast< wxWindow * >(argp1);
31407 {
31408 PyThreadState* __tstate = wxPyBeginAllowThreads();
31409 result = ((wxWindow const *)arg1)->GetMaxSize();
31410 wxPyEndAllowThreads(__tstate);
31411 if (PyErr_Occurred()) SWIG_fail;
31412 }
31413 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31414 return resultobj;
31415 fail:
31416 return NULL;
31417 }
31418
31419
31420 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31421 PyObject *resultobj = 0;
31422 wxWindow *arg1 = (wxWindow *) 0 ;
31423 wxSize result;
31424 void *argp1 = 0 ;
31425 int res1 = 0 ;
31426 PyObject *swig_obj[1] ;
31427
31428 if (!args) SWIG_fail;
31429 swig_obj[0] = args;
31430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31431 if (!SWIG_IsOK(res1)) {
31432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31433 }
31434 arg1 = reinterpret_cast< wxWindow * >(argp1);
31435 {
31436 PyThreadState* __tstate = wxPyBeginAllowThreads();
31437 result = ((wxWindow const *)arg1)->GetMinSize();
31438 wxPyEndAllowThreads(__tstate);
31439 if (PyErr_Occurred()) SWIG_fail;
31440 }
31441 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31442 return resultobj;
31443 fail:
31444 return NULL;
31445 }
31446
31447
31448 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31449 PyObject *resultobj = 0;
31450 wxWindow *arg1 = (wxWindow *) 0 ;
31451 wxSize *arg2 = 0 ;
31452 void *argp1 = 0 ;
31453 int res1 = 0 ;
31454 wxSize temp2 ;
31455 PyObject * obj0 = 0 ;
31456 PyObject * obj1 = 0 ;
31457 char * kwnames[] = {
31458 (char *) "self",(char *) "minSize", NULL
31459 };
31460
31461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31463 if (!SWIG_IsOK(res1)) {
31464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31465 }
31466 arg1 = reinterpret_cast< wxWindow * >(argp1);
31467 {
31468 arg2 = &temp2;
31469 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31470 }
31471 {
31472 PyThreadState* __tstate = wxPyBeginAllowThreads();
31473 (arg1)->SetMinSize((wxSize const &)*arg2);
31474 wxPyEndAllowThreads(__tstate);
31475 if (PyErr_Occurred()) SWIG_fail;
31476 }
31477 resultobj = SWIG_Py_Void();
31478 return resultobj;
31479 fail:
31480 return NULL;
31481 }
31482
31483
31484 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31485 PyObject *resultobj = 0;
31486 wxWindow *arg1 = (wxWindow *) 0 ;
31487 wxSize *arg2 = 0 ;
31488 void *argp1 = 0 ;
31489 int res1 = 0 ;
31490 wxSize temp2 ;
31491 PyObject * obj0 = 0 ;
31492 PyObject * obj1 = 0 ;
31493 char * kwnames[] = {
31494 (char *) "self",(char *) "maxSize", NULL
31495 };
31496
31497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31499 if (!SWIG_IsOK(res1)) {
31500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31501 }
31502 arg1 = reinterpret_cast< wxWindow * >(argp1);
31503 {
31504 arg2 = &temp2;
31505 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31506 }
31507 {
31508 PyThreadState* __tstate = wxPyBeginAllowThreads();
31509 (arg1)->SetMaxSize((wxSize const &)*arg2);
31510 wxPyEndAllowThreads(__tstate);
31511 if (PyErr_Occurred()) SWIG_fail;
31512 }
31513 resultobj = SWIG_Py_Void();
31514 return resultobj;
31515 fail:
31516 return NULL;
31517 }
31518
31519
31520 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31521 PyObject *resultobj = 0;
31522 wxWindow *arg1 = (wxWindow *) 0 ;
31523 int result;
31524 void *argp1 = 0 ;
31525 int res1 = 0 ;
31526 PyObject *swig_obj[1] ;
31527
31528 if (!args) SWIG_fail;
31529 swig_obj[0] = args;
31530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31531 if (!SWIG_IsOK(res1)) {
31532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31533 }
31534 arg1 = reinterpret_cast< wxWindow * >(argp1);
31535 {
31536 PyThreadState* __tstate = wxPyBeginAllowThreads();
31537 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31538 wxPyEndAllowThreads(__tstate);
31539 if (PyErr_Occurred()) SWIG_fail;
31540 }
31541 resultobj = SWIG_From_int(static_cast< int >(result));
31542 return resultobj;
31543 fail:
31544 return NULL;
31545 }
31546
31547
31548 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31549 PyObject *resultobj = 0;
31550 wxWindow *arg1 = (wxWindow *) 0 ;
31551 int result;
31552 void *argp1 = 0 ;
31553 int res1 = 0 ;
31554 PyObject *swig_obj[1] ;
31555
31556 if (!args) SWIG_fail;
31557 swig_obj[0] = args;
31558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31559 if (!SWIG_IsOK(res1)) {
31560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31561 }
31562 arg1 = reinterpret_cast< wxWindow * >(argp1);
31563 {
31564 PyThreadState* __tstate = wxPyBeginAllowThreads();
31565 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31566 wxPyEndAllowThreads(__tstate);
31567 if (PyErr_Occurred()) SWIG_fail;
31568 }
31569 resultobj = SWIG_From_int(static_cast< int >(result));
31570 return resultobj;
31571 fail:
31572 return NULL;
31573 }
31574
31575
31576 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31577 PyObject *resultobj = 0;
31578 wxWindow *arg1 = (wxWindow *) 0 ;
31579 int result;
31580 void *argp1 = 0 ;
31581 int res1 = 0 ;
31582 PyObject *swig_obj[1] ;
31583
31584 if (!args) SWIG_fail;
31585 swig_obj[0] = args;
31586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31587 if (!SWIG_IsOK(res1)) {
31588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31589 }
31590 arg1 = reinterpret_cast< wxWindow * >(argp1);
31591 {
31592 PyThreadState* __tstate = wxPyBeginAllowThreads();
31593 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31594 wxPyEndAllowThreads(__tstate);
31595 if (PyErr_Occurred()) SWIG_fail;
31596 }
31597 resultobj = SWIG_From_int(static_cast< int >(result));
31598 return resultobj;
31599 fail:
31600 return NULL;
31601 }
31602
31603
31604 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31605 PyObject *resultobj = 0;
31606 wxWindow *arg1 = (wxWindow *) 0 ;
31607 int result;
31608 void *argp1 = 0 ;
31609 int res1 = 0 ;
31610 PyObject *swig_obj[1] ;
31611
31612 if (!args) SWIG_fail;
31613 swig_obj[0] = args;
31614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31615 if (!SWIG_IsOK(res1)) {
31616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31617 }
31618 arg1 = reinterpret_cast< wxWindow * >(argp1);
31619 {
31620 PyThreadState* __tstate = wxPyBeginAllowThreads();
31621 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31622 wxPyEndAllowThreads(__tstate);
31623 if (PyErr_Occurred()) SWIG_fail;
31624 }
31625 resultobj = SWIG_From_int(static_cast< int >(result));
31626 return resultobj;
31627 fail:
31628 return NULL;
31629 }
31630
31631
31632 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31633 PyObject *resultobj = 0;
31634 wxWindow *arg1 = (wxWindow *) 0 ;
31635 wxSize *arg2 = 0 ;
31636 void *argp1 = 0 ;
31637 int res1 = 0 ;
31638 wxSize temp2 ;
31639 PyObject * obj0 = 0 ;
31640 PyObject * obj1 = 0 ;
31641 char * kwnames[] = {
31642 (char *) "self",(char *) "size", NULL
31643 };
31644
31645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31647 if (!SWIG_IsOK(res1)) {
31648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31649 }
31650 arg1 = reinterpret_cast< wxWindow * >(argp1);
31651 {
31652 arg2 = &temp2;
31653 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31654 }
31655 {
31656 PyThreadState* __tstate = wxPyBeginAllowThreads();
31657 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31658 wxPyEndAllowThreads(__tstate);
31659 if (PyErr_Occurred()) SWIG_fail;
31660 }
31661 resultobj = SWIG_Py_Void();
31662 return resultobj;
31663 fail:
31664 return NULL;
31665 }
31666
31667
31668 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31669 PyObject *resultobj = 0;
31670 wxWindow *arg1 = (wxWindow *) 0 ;
31671 int arg2 ;
31672 int arg3 ;
31673 void *argp1 = 0 ;
31674 int res1 = 0 ;
31675 int val2 ;
31676 int ecode2 = 0 ;
31677 int val3 ;
31678 int ecode3 = 0 ;
31679 PyObject * obj0 = 0 ;
31680 PyObject * obj1 = 0 ;
31681 PyObject * obj2 = 0 ;
31682 char * kwnames[] = {
31683 (char *) "self",(char *) "w",(char *) "h", NULL
31684 };
31685
31686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31688 if (!SWIG_IsOK(res1)) {
31689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31690 }
31691 arg1 = reinterpret_cast< wxWindow * >(argp1);
31692 ecode2 = SWIG_AsVal_int(obj1, &val2);
31693 if (!SWIG_IsOK(ecode2)) {
31694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31695 }
31696 arg2 = static_cast< int >(val2);
31697 ecode3 = SWIG_AsVal_int(obj2, &val3);
31698 if (!SWIG_IsOK(ecode3)) {
31699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31700 }
31701 arg3 = static_cast< int >(val3);
31702 {
31703 PyThreadState* __tstate = wxPyBeginAllowThreads();
31704 (arg1)->SetVirtualSize(arg2,arg3);
31705 wxPyEndAllowThreads(__tstate);
31706 if (PyErr_Occurred()) SWIG_fail;
31707 }
31708 resultobj = SWIG_Py_Void();
31709 return resultobj;
31710 fail:
31711 return NULL;
31712 }
31713
31714
31715 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31716 PyObject *resultobj = 0;
31717 wxWindow *arg1 = (wxWindow *) 0 ;
31718 wxSize result;
31719 void *argp1 = 0 ;
31720 int res1 = 0 ;
31721 PyObject *swig_obj[1] ;
31722
31723 if (!args) SWIG_fail;
31724 swig_obj[0] = args;
31725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31726 if (!SWIG_IsOK(res1)) {
31727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31728 }
31729 arg1 = reinterpret_cast< wxWindow * >(argp1);
31730 {
31731 PyThreadState* __tstate = wxPyBeginAllowThreads();
31732 result = ((wxWindow const *)arg1)->GetVirtualSize();
31733 wxPyEndAllowThreads(__tstate);
31734 if (PyErr_Occurred()) SWIG_fail;
31735 }
31736 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31737 return resultobj;
31738 fail:
31739 return NULL;
31740 }
31741
31742
31743 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31744 PyObject *resultobj = 0;
31745 wxWindow *arg1 = (wxWindow *) 0 ;
31746 int *arg2 = (int *) 0 ;
31747 int *arg3 = (int *) 0 ;
31748 void *argp1 = 0 ;
31749 int res1 = 0 ;
31750 int temp2 ;
31751 int res2 = SWIG_TMPOBJ ;
31752 int temp3 ;
31753 int res3 = SWIG_TMPOBJ ;
31754 PyObject *swig_obj[1] ;
31755
31756 arg2 = &temp2;
31757 arg3 = &temp3;
31758 if (!args) SWIG_fail;
31759 swig_obj[0] = args;
31760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31761 if (!SWIG_IsOK(res1)) {
31762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31763 }
31764 arg1 = reinterpret_cast< wxWindow * >(argp1);
31765 {
31766 PyThreadState* __tstate = wxPyBeginAllowThreads();
31767 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31768 wxPyEndAllowThreads(__tstate);
31769 if (PyErr_Occurred()) SWIG_fail;
31770 }
31771 resultobj = SWIG_Py_Void();
31772 if (SWIG_IsTmpObj(res2)) {
31773 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31774 } else {
31775 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31776 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31777 }
31778 if (SWIG_IsTmpObj(res3)) {
31779 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31780 } else {
31781 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31782 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31783 }
31784 return resultobj;
31785 fail:
31786 return NULL;
31787 }
31788
31789
31790 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31791 PyObject *resultobj = 0;
31792 wxWindow *arg1 = (wxWindow *) 0 ;
31793 wxSize result;
31794 void *argp1 = 0 ;
31795 int res1 = 0 ;
31796 PyObject *swig_obj[1] ;
31797
31798 if (!args) SWIG_fail;
31799 swig_obj[0] = args;
31800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31801 if (!SWIG_IsOK(res1)) {
31802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31803 }
31804 arg1 = reinterpret_cast< wxWindow * >(argp1);
31805 {
31806 PyThreadState* __tstate = wxPyBeginAllowThreads();
31807 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
31808 wxPyEndAllowThreads(__tstate);
31809 if (PyErr_Occurred()) SWIG_fail;
31810 }
31811 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31812 return resultobj;
31813 fail:
31814 return NULL;
31815 }
31816
31817
31818 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31819 PyObject *resultobj = 0;
31820 wxWindow *arg1 = (wxWindow *) 0 ;
31821 bool arg2 = (bool) true ;
31822 bool result;
31823 void *argp1 = 0 ;
31824 int res1 = 0 ;
31825 bool val2 ;
31826 int ecode2 = 0 ;
31827 PyObject * obj0 = 0 ;
31828 PyObject * obj1 = 0 ;
31829 char * kwnames[] = {
31830 (char *) "self",(char *) "show", NULL
31831 };
31832
31833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
31834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31835 if (!SWIG_IsOK(res1)) {
31836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
31837 }
31838 arg1 = reinterpret_cast< wxWindow * >(argp1);
31839 if (obj1) {
31840 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31841 if (!SWIG_IsOK(ecode2)) {
31842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
31843 }
31844 arg2 = static_cast< bool >(val2);
31845 }
31846 {
31847 PyThreadState* __tstate = wxPyBeginAllowThreads();
31848 result = (bool)(arg1)->Show(arg2);
31849 wxPyEndAllowThreads(__tstate);
31850 if (PyErr_Occurred()) SWIG_fail;
31851 }
31852 {
31853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31854 }
31855 return resultobj;
31856 fail:
31857 return NULL;
31858 }
31859
31860
31861 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31862 PyObject *resultobj = 0;
31863 wxWindow *arg1 = (wxWindow *) 0 ;
31864 bool result;
31865 void *argp1 = 0 ;
31866 int res1 = 0 ;
31867 PyObject *swig_obj[1] ;
31868
31869 if (!args) SWIG_fail;
31870 swig_obj[0] = args;
31871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31872 if (!SWIG_IsOK(res1)) {
31873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
31874 }
31875 arg1 = reinterpret_cast< wxWindow * >(argp1);
31876 {
31877 PyThreadState* __tstate = wxPyBeginAllowThreads();
31878 result = (bool)(arg1)->Hide();
31879 wxPyEndAllowThreads(__tstate);
31880 if (PyErr_Occurred()) SWIG_fail;
31881 }
31882 {
31883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31884 }
31885 return resultobj;
31886 fail:
31887 return NULL;
31888 }
31889
31890
31891 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31892 PyObject *resultobj = 0;
31893 wxWindow *arg1 = (wxWindow *) 0 ;
31894 bool arg2 = (bool) true ;
31895 bool result;
31896 void *argp1 = 0 ;
31897 int res1 = 0 ;
31898 bool val2 ;
31899 int ecode2 = 0 ;
31900 PyObject * obj0 = 0 ;
31901 PyObject * obj1 = 0 ;
31902 char * kwnames[] = {
31903 (char *) "self",(char *) "enable", NULL
31904 };
31905
31906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
31907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31908 if (!SWIG_IsOK(res1)) {
31909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
31910 }
31911 arg1 = reinterpret_cast< wxWindow * >(argp1);
31912 if (obj1) {
31913 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31914 if (!SWIG_IsOK(ecode2)) {
31915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
31916 }
31917 arg2 = static_cast< bool >(val2);
31918 }
31919 {
31920 PyThreadState* __tstate = wxPyBeginAllowThreads();
31921 result = (bool)(arg1)->Enable(arg2);
31922 wxPyEndAllowThreads(__tstate);
31923 if (PyErr_Occurred()) SWIG_fail;
31924 }
31925 {
31926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31927 }
31928 return resultobj;
31929 fail:
31930 return NULL;
31931 }
31932
31933
31934 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31935 PyObject *resultobj = 0;
31936 wxWindow *arg1 = (wxWindow *) 0 ;
31937 bool result;
31938 void *argp1 = 0 ;
31939 int res1 = 0 ;
31940 PyObject *swig_obj[1] ;
31941
31942 if (!args) SWIG_fail;
31943 swig_obj[0] = args;
31944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31945 if (!SWIG_IsOK(res1)) {
31946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
31947 }
31948 arg1 = reinterpret_cast< wxWindow * >(argp1);
31949 {
31950 PyThreadState* __tstate = wxPyBeginAllowThreads();
31951 result = (bool)(arg1)->Disable();
31952 wxPyEndAllowThreads(__tstate);
31953 if (PyErr_Occurred()) SWIG_fail;
31954 }
31955 {
31956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31957 }
31958 return resultobj;
31959 fail:
31960 return NULL;
31961 }
31962
31963
31964 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31965 PyObject *resultobj = 0;
31966 wxWindow *arg1 = (wxWindow *) 0 ;
31967 bool result;
31968 void *argp1 = 0 ;
31969 int res1 = 0 ;
31970 PyObject *swig_obj[1] ;
31971
31972 if (!args) SWIG_fail;
31973 swig_obj[0] = args;
31974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31975 if (!SWIG_IsOK(res1)) {
31976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
31977 }
31978 arg1 = reinterpret_cast< wxWindow * >(argp1);
31979 {
31980 PyThreadState* __tstate = wxPyBeginAllowThreads();
31981 result = (bool)((wxWindow const *)arg1)->IsShown();
31982 wxPyEndAllowThreads(__tstate);
31983 if (PyErr_Occurred()) SWIG_fail;
31984 }
31985 {
31986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31987 }
31988 return resultobj;
31989 fail:
31990 return NULL;
31991 }
31992
31993
31994 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31995 PyObject *resultobj = 0;
31996 wxWindow *arg1 = (wxWindow *) 0 ;
31997 bool result;
31998 void *argp1 = 0 ;
31999 int res1 = 0 ;
32000 PyObject *swig_obj[1] ;
32001
32002 if (!args) SWIG_fail;
32003 swig_obj[0] = args;
32004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32005 if (!SWIG_IsOK(res1)) {
32006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32007 }
32008 arg1 = reinterpret_cast< wxWindow * >(argp1);
32009 {
32010 PyThreadState* __tstate = wxPyBeginAllowThreads();
32011 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32012 wxPyEndAllowThreads(__tstate);
32013 if (PyErr_Occurred()) SWIG_fail;
32014 }
32015 {
32016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32017 }
32018 return resultobj;
32019 fail:
32020 return NULL;
32021 }
32022
32023
32024 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32025 PyObject *resultobj = 0;
32026 wxWindow *arg1 = (wxWindow *) 0 ;
32027 long arg2 ;
32028 void *argp1 = 0 ;
32029 int res1 = 0 ;
32030 long val2 ;
32031 int ecode2 = 0 ;
32032 PyObject * obj0 = 0 ;
32033 PyObject * obj1 = 0 ;
32034 char * kwnames[] = {
32035 (char *) "self",(char *) "style", NULL
32036 };
32037
32038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32040 if (!SWIG_IsOK(res1)) {
32041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32042 }
32043 arg1 = reinterpret_cast< wxWindow * >(argp1);
32044 ecode2 = SWIG_AsVal_long(obj1, &val2);
32045 if (!SWIG_IsOK(ecode2)) {
32046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32047 }
32048 arg2 = static_cast< long >(val2);
32049 {
32050 PyThreadState* __tstate = wxPyBeginAllowThreads();
32051 (arg1)->SetWindowStyleFlag(arg2);
32052 wxPyEndAllowThreads(__tstate);
32053 if (PyErr_Occurred()) SWIG_fail;
32054 }
32055 resultobj = SWIG_Py_Void();
32056 return resultobj;
32057 fail:
32058 return NULL;
32059 }
32060
32061
32062 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32063 PyObject *resultobj = 0;
32064 wxWindow *arg1 = (wxWindow *) 0 ;
32065 long result;
32066 void *argp1 = 0 ;
32067 int res1 = 0 ;
32068 PyObject *swig_obj[1] ;
32069
32070 if (!args) SWIG_fail;
32071 swig_obj[0] = args;
32072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32073 if (!SWIG_IsOK(res1)) {
32074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32075 }
32076 arg1 = reinterpret_cast< wxWindow * >(argp1);
32077 {
32078 PyThreadState* __tstate = wxPyBeginAllowThreads();
32079 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32080 wxPyEndAllowThreads(__tstate);
32081 if (PyErr_Occurred()) SWIG_fail;
32082 }
32083 resultobj = SWIG_From_long(static_cast< long >(result));
32084 return resultobj;
32085 fail:
32086 return NULL;
32087 }
32088
32089
32090 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32091 PyObject *resultobj = 0;
32092 wxWindow *arg1 = (wxWindow *) 0 ;
32093 int arg2 ;
32094 bool result;
32095 void *argp1 = 0 ;
32096 int res1 = 0 ;
32097 int val2 ;
32098 int ecode2 = 0 ;
32099 PyObject * obj0 = 0 ;
32100 PyObject * obj1 = 0 ;
32101 char * kwnames[] = {
32102 (char *) "self",(char *) "flag", NULL
32103 };
32104
32105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32107 if (!SWIG_IsOK(res1)) {
32108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32109 }
32110 arg1 = reinterpret_cast< wxWindow * >(argp1);
32111 ecode2 = SWIG_AsVal_int(obj1, &val2);
32112 if (!SWIG_IsOK(ecode2)) {
32113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32114 }
32115 arg2 = static_cast< int >(val2);
32116 {
32117 PyThreadState* __tstate = wxPyBeginAllowThreads();
32118 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32119 wxPyEndAllowThreads(__tstate);
32120 if (PyErr_Occurred()) SWIG_fail;
32121 }
32122 {
32123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32124 }
32125 return resultobj;
32126 fail:
32127 return NULL;
32128 }
32129
32130
32131 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32132 PyObject *resultobj = 0;
32133 wxWindow *arg1 = (wxWindow *) 0 ;
32134 bool result;
32135 void *argp1 = 0 ;
32136 int res1 = 0 ;
32137 PyObject *swig_obj[1] ;
32138
32139 if (!args) SWIG_fail;
32140 swig_obj[0] = args;
32141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32142 if (!SWIG_IsOK(res1)) {
32143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32144 }
32145 arg1 = reinterpret_cast< wxWindow * >(argp1);
32146 {
32147 PyThreadState* __tstate = wxPyBeginAllowThreads();
32148 result = (bool)((wxWindow const *)arg1)->IsRetained();
32149 wxPyEndAllowThreads(__tstate);
32150 if (PyErr_Occurred()) SWIG_fail;
32151 }
32152 {
32153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32154 }
32155 return resultobj;
32156 fail:
32157 return NULL;
32158 }
32159
32160
32161 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32162 PyObject *resultobj = 0;
32163 wxWindow *arg1 = (wxWindow *) 0 ;
32164 long arg2 ;
32165 void *argp1 = 0 ;
32166 int res1 = 0 ;
32167 long val2 ;
32168 int ecode2 = 0 ;
32169 PyObject * obj0 = 0 ;
32170 PyObject * obj1 = 0 ;
32171 char * kwnames[] = {
32172 (char *) "self",(char *) "exStyle", NULL
32173 };
32174
32175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32177 if (!SWIG_IsOK(res1)) {
32178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32179 }
32180 arg1 = reinterpret_cast< wxWindow * >(argp1);
32181 ecode2 = SWIG_AsVal_long(obj1, &val2);
32182 if (!SWIG_IsOK(ecode2)) {
32183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32184 }
32185 arg2 = static_cast< long >(val2);
32186 {
32187 PyThreadState* __tstate = wxPyBeginAllowThreads();
32188 (arg1)->SetExtraStyle(arg2);
32189 wxPyEndAllowThreads(__tstate);
32190 if (PyErr_Occurred()) SWIG_fail;
32191 }
32192 resultobj = SWIG_Py_Void();
32193 return resultobj;
32194 fail:
32195 return NULL;
32196 }
32197
32198
32199 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32200 PyObject *resultobj = 0;
32201 wxWindow *arg1 = (wxWindow *) 0 ;
32202 long result;
32203 void *argp1 = 0 ;
32204 int res1 = 0 ;
32205 PyObject *swig_obj[1] ;
32206
32207 if (!args) SWIG_fail;
32208 swig_obj[0] = args;
32209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32210 if (!SWIG_IsOK(res1)) {
32211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32212 }
32213 arg1 = reinterpret_cast< wxWindow * >(argp1);
32214 {
32215 PyThreadState* __tstate = wxPyBeginAllowThreads();
32216 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32217 wxPyEndAllowThreads(__tstate);
32218 if (PyErr_Occurred()) SWIG_fail;
32219 }
32220 resultobj = SWIG_From_long(static_cast< long >(result));
32221 return resultobj;
32222 fail:
32223 return NULL;
32224 }
32225
32226
32227 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32228 PyObject *resultobj = 0;
32229 wxWindow *arg1 = (wxWindow *) 0 ;
32230 bool arg2 = (bool) true ;
32231 void *argp1 = 0 ;
32232 int res1 = 0 ;
32233 bool val2 ;
32234 int ecode2 = 0 ;
32235 PyObject * obj0 = 0 ;
32236 PyObject * obj1 = 0 ;
32237 char * kwnames[] = {
32238 (char *) "self",(char *) "modal", NULL
32239 };
32240
32241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32243 if (!SWIG_IsOK(res1)) {
32244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32245 }
32246 arg1 = reinterpret_cast< wxWindow * >(argp1);
32247 if (obj1) {
32248 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32249 if (!SWIG_IsOK(ecode2)) {
32250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32251 }
32252 arg2 = static_cast< bool >(val2);
32253 }
32254 {
32255 PyThreadState* __tstate = wxPyBeginAllowThreads();
32256 (arg1)->MakeModal(arg2);
32257 wxPyEndAllowThreads(__tstate);
32258 if (PyErr_Occurred()) SWIG_fail;
32259 }
32260 resultobj = SWIG_Py_Void();
32261 return resultobj;
32262 fail:
32263 return NULL;
32264 }
32265
32266
32267 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32268 PyObject *resultobj = 0;
32269 wxWindow *arg1 = (wxWindow *) 0 ;
32270 bool arg2 ;
32271 void *argp1 = 0 ;
32272 int res1 = 0 ;
32273 bool val2 ;
32274 int ecode2 = 0 ;
32275 PyObject * obj0 = 0 ;
32276 PyObject * obj1 = 0 ;
32277 char * kwnames[] = {
32278 (char *) "self",(char *) "enableTheme", NULL
32279 };
32280
32281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32283 if (!SWIG_IsOK(res1)) {
32284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32285 }
32286 arg1 = reinterpret_cast< wxWindow * >(argp1);
32287 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32288 if (!SWIG_IsOK(ecode2)) {
32289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32290 }
32291 arg2 = static_cast< bool >(val2);
32292 {
32293 PyThreadState* __tstate = wxPyBeginAllowThreads();
32294 (arg1)->SetThemeEnabled(arg2);
32295 wxPyEndAllowThreads(__tstate);
32296 if (PyErr_Occurred()) SWIG_fail;
32297 }
32298 resultobj = SWIG_Py_Void();
32299 return resultobj;
32300 fail:
32301 return NULL;
32302 }
32303
32304
32305 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32306 PyObject *resultobj = 0;
32307 wxWindow *arg1 = (wxWindow *) 0 ;
32308 bool result;
32309 void *argp1 = 0 ;
32310 int res1 = 0 ;
32311 PyObject *swig_obj[1] ;
32312
32313 if (!args) SWIG_fail;
32314 swig_obj[0] = args;
32315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32316 if (!SWIG_IsOK(res1)) {
32317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32318 }
32319 arg1 = reinterpret_cast< wxWindow * >(argp1);
32320 {
32321 PyThreadState* __tstate = wxPyBeginAllowThreads();
32322 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32323 wxPyEndAllowThreads(__tstate);
32324 if (PyErr_Occurred()) SWIG_fail;
32325 }
32326 {
32327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32328 }
32329 return resultobj;
32330 fail:
32331 return NULL;
32332 }
32333
32334
32335 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32336 PyObject *resultobj = 0;
32337 wxWindow *arg1 = (wxWindow *) 0 ;
32338 void *argp1 = 0 ;
32339 int res1 = 0 ;
32340 PyObject *swig_obj[1] ;
32341
32342 if (!args) SWIG_fail;
32343 swig_obj[0] = args;
32344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32345 if (!SWIG_IsOK(res1)) {
32346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32347 }
32348 arg1 = reinterpret_cast< wxWindow * >(argp1);
32349 {
32350 PyThreadState* __tstate = wxPyBeginAllowThreads();
32351 (arg1)->SetFocus();
32352 wxPyEndAllowThreads(__tstate);
32353 if (PyErr_Occurred()) SWIG_fail;
32354 }
32355 resultobj = SWIG_Py_Void();
32356 return resultobj;
32357 fail:
32358 return NULL;
32359 }
32360
32361
32362 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32363 PyObject *resultobj = 0;
32364 wxWindow *arg1 = (wxWindow *) 0 ;
32365 void *argp1 = 0 ;
32366 int res1 = 0 ;
32367 PyObject *swig_obj[1] ;
32368
32369 if (!args) SWIG_fail;
32370 swig_obj[0] = args;
32371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32372 if (!SWIG_IsOK(res1)) {
32373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32374 }
32375 arg1 = reinterpret_cast< wxWindow * >(argp1);
32376 {
32377 PyThreadState* __tstate = wxPyBeginAllowThreads();
32378 (arg1)->SetFocusFromKbd();
32379 wxPyEndAllowThreads(__tstate);
32380 if (PyErr_Occurred()) SWIG_fail;
32381 }
32382 resultobj = SWIG_Py_Void();
32383 return resultobj;
32384 fail:
32385 return NULL;
32386 }
32387
32388
32389 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32390 PyObject *resultobj = 0;
32391 wxWindow *result = 0 ;
32392
32393 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32394 {
32395 if (!wxPyCheckForApp()) SWIG_fail;
32396 PyThreadState* __tstate = wxPyBeginAllowThreads();
32397 result = (wxWindow *)wxWindow::FindFocus();
32398 wxPyEndAllowThreads(__tstate);
32399 if (PyErr_Occurred()) SWIG_fail;
32400 }
32401 {
32402 resultobj = wxPyMake_wxObject(result, 0);
32403 }
32404 return resultobj;
32405 fail:
32406 return NULL;
32407 }
32408
32409
32410 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32411 PyObject *resultobj = 0;
32412 wxWindow *arg1 = (wxWindow *) 0 ;
32413 bool result;
32414 void *argp1 = 0 ;
32415 int res1 = 0 ;
32416 PyObject *swig_obj[1] ;
32417
32418 if (!args) SWIG_fail;
32419 swig_obj[0] = args;
32420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32421 if (!SWIG_IsOK(res1)) {
32422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32423 }
32424 arg1 = reinterpret_cast< wxWindow * >(argp1);
32425 {
32426 PyThreadState* __tstate = wxPyBeginAllowThreads();
32427 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32428 wxPyEndAllowThreads(__tstate);
32429 if (PyErr_Occurred()) SWIG_fail;
32430 }
32431 {
32432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32433 }
32434 return resultobj;
32435 fail:
32436 return NULL;
32437 }
32438
32439
32440 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32441 PyObject *resultobj = 0;
32442 wxWindow *arg1 = (wxWindow *) 0 ;
32443 bool result;
32444 void *argp1 = 0 ;
32445 int res1 = 0 ;
32446 PyObject *swig_obj[1] ;
32447
32448 if (!args) SWIG_fail;
32449 swig_obj[0] = args;
32450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32451 if (!SWIG_IsOK(res1)) {
32452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32453 }
32454 arg1 = reinterpret_cast< wxWindow * >(argp1);
32455 {
32456 PyThreadState* __tstate = wxPyBeginAllowThreads();
32457 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32458 wxPyEndAllowThreads(__tstate);
32459 if (PyErr_Occurred()) SWIG_fail;
32460 }
32461 {
32462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32463 }
32464 return resultobj;
32465 fail:
32466 return NULL;
32467 }
32468
32469
32470 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32471 PyObject *resultobj = 0;
32472 wxWindow *arg1 = (wxWindow *) 0 ;
32473 wxWindow *result = 0 ;
32474 void *argp1 = 0 ;
32475 int res1 = 0 ;
32476 PyObject *swig_obj[1] ;
32477
32478 if (!args) SWIG_fail;
32479 swig_obj[0] = args;
32480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32481 if (!SWIG_IsOK(res1)) {
32482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32483 }
32484 arg1 = reinterpret_cast< wxWindow * >(argp1);
32485 {
32486 PyThreadState* __tstate = wxPyBeginAllowThreads();
32487 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32488 wxPyEndAllowThreads(__tstate);
32489 if (PyErr_Occurred()) SWIG_fail;
32490 }
32491 {
32492 resultobj = wxPyMake_wxObject(result, 0);
32493 }
32494 return resultobj;
32495 fail:
32496 return NULL;
32497 }
32498
32499
32500 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32501 PyObject *resultobj = 0;
32502 wxWindow *arg1 = (wxWindow *) 0 ;
32503 wxWindow *arg2 = (wxWindow *) 0 ;
32504 wxWindow *result = 0 ;
32505 void *argp1 = 0 ;
32506 int res1 = 0 ;
32507 void *argp2 = 0 ;
32508 int res2 = 0 ;
32509 PyObject * obj0 = 0 ;
32510 PyObject * obj1 = 0 ;
32511 char * kwnames[] = {
32512 (char *) "self",(char *) "child", NULL
32513 };
32514
32515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32517 if (!SWIG_IsOK(res1)) {
32518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32519 }
32520 arg1 = reinterpret_cast< wxWindow * >(argp1);
32521 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32522 if (!SWIG_IsOK(res2)) {
32523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32524 }
32525 arg2 = reinterpret_cast< wxWindow * >(argp2);
32526 {
32527 PyThreadState* __tstate = wxPyBeginAllowThreads();
32528 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32529 wxPyEndAllowThreads(__tstate);
32530 if (PyErr_Occurred()) SWIG_fail;
32531 }
32532 {
32533 resultobj = wxPyMake_wxObject(result, 0);
32534 }
32535 return resultobj;
32536 fail:
32537 return NULL;
32538 }
32539
32540
32541 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32542 PyObject *resultobj = 0;
32543 wxWindow *arg1 = (wxWindow *) 0 ;
32544 wxWindow *arg2 = (wxWindow *) 0 ;
32545 void *argp1 = 0 ;
32546 int res1 = 0 ;
32547 void *argp2 = 0 ;
32548 int res2 = 0 ;
32549 PyObject * obj0 = 0 ;
32550 PyObject * obj1 = 0 ;
32551 char * kwnames[] = {
32552 (char *) "self",(char *) "win", NULL
32553 };
32554
32555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32557 if (!SWIG_IsOK(res1)) {
32558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32559 }
32560 arg1 = reinterpret_cast< wxWindow * >(argp1);
32561 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32562 if (!SWIG_IsOK(res2)) {
32563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32564 }
32565 arg2 = reinterpret_cast< wxWindow * >(argp2);
32566 {
32567 PyThreadState* __tstate = wxPyBeginAllowThreads();
32568 (arg1)->SetTmpDefaultItem(arg2);
32569 wxPyEndAllowThreads(__tstate);
32570 if (PyErr_Occurred()) SWIG_fail;
32571 }
32572 resultobj = SWIG_Py_Void();
32573 return resultobj;
32574 fail:
32575 return NULL;
32576 }
32577
32578
32579 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32580 PyObject *resultobj = 0;
32581 wxWindow *arg1 = (wxWindow *) 0 ;
32582 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32583 bool result;
32584 void *argp1 = 0 ;
32585 int res1 = 0 ;
32586 int val2 ;
32587 int ecode2 = 0 ;
32588 PyObject * obj0 = 0 ;
32589 PyObject * obj1 = 0 ;
32590 char * kwnames[] = {
32591 (char *) "self",(char *) "flags", NULL
32592 };
32593
32594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32596 if (!SWIG_IsOK(res1)) {
32597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32598 }
32599 arg1 = reinterpret_cast< wxWindow * >(argp1);
32600 if (obj1) {
32601 ecode2 = SWIG_AsVal_int(obj1, &val2);
32602 if (!SWIG_IsOK(ecode2)) {
32603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32604 }
32605 arg2 = static_cast< int >(val2);
32606 }
32607 {
32608 PyThreadState* __tstate = wxPyBeginAllowThreads();
32609 result = (bool)(arg1)->Navigate(arg2);
32610 wxPyEndAllowThreads(__tstate);
32611 if (PyErr_Occurred()) SWIG_fail;
32612 }
32613 {
32614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32615 }
32616 return resultobj;
32617 fail:
32618 return NULL;
32619 }
32620
32621
32622 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32623 PyObject *resultobj = 0;
32624 wxWindow *arg1 = (wxWindow *) 0 ;
32625 wxWindow *arg2 = (wxWindow *) 0 ;
32626 void *argp1 = 0 ;
32627 int res1 = 0 ;
32628 void *argp2 = 0 ;
32629 int res2 = 0 ;
32630 PyObject * obj0 = 0 ;
32631 PyObject * obj1 = 0 ;
32632 char * kwnames[] = {
32633 (char *) "self",(char *) "win", NULL
32634 };
32635
32636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32638 if (!SWIG_IsOK(res1)) {
32639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32640 }
32641 arg1 = reinterpret_cast< wxWindow * >(argp1);
32642 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32643 if (!SWIG_IsOK(res2)) {
32644 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32645 }
32646 arg2 = reinterpret_cast< wxWindow * >(argp2);
32647 {
32648 PyThreadState* __tstate = wxPyBeginAllowThreads();
32649 (arg1)->MoveAfterInTabOrder(arg2);
32650 wxPyEndAllowThreads(__tstate);
32651 if (PyErr_Occurred()) SWIG_fail;
32652 }
32653 resultobj = SWIG_Py_Void();
32654 return resultobj;
32655 fail:
32656 return NULL;
32657 }
32658
32659
32660 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32661 PyObject *resultobj = 0;
32662 wxWindow *arg1 = (wxWindow *) 0 ;
32663 wxWindow *arg2 = (wxWindow *) 0 ;
32664 void *argp1 = 0 ;
32665 int res1 = 0 ;
32666 void *argp2 = 0 ;
32667 int res2 = 0 ;
32668 PyObject * obj0 = 0 ;
32669 PyObject * obj1 = 0 ;
32670 char * kwnames[] = {
32671 (char *) "self",(char *) "win", NULL
32672 };
32673
32674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32676 if (!SWIG_IsOK(res1)) {
32677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32678 }
32679 arg1 = reinterpret_cast< wxWindow * >(argp1);
32680 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32681 if (!SWIG_IsOK(res2)) {
32682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32683 }
32684 arg2 = reinterpret_cast< wxWindow * >(argp2);
32685 {
32686 PyThreadState* __tstate = wxPyBeginAllowThreads();
32687 (arg1)->MoveBeforeInTabOrder(arg2);
32688 wxPyEndAllowThreads(__tstate);
32689 if (PyErr_Occurred()) SWIG_fail;
32690 }
32691 resultobj = SWIG_Py_Void();
32692 return resultobj;
32693 fail:
32694 return NULL;
32695 }
32696
32697
32698 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32699 PyObject *resultobj = 0;
32700 wxWindow *arg1 = (wxWindow *) 0 ;
32701 PyObject *result = 0 ;
32702 void *argp1 = 0 ;
32703 int res1 = 0 ;
32704 PyObject *swig_obj[1] ;
32705
32706 if (!args) SWIG_fail;
32707 swig_obj[0] = args;
32708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32709 if (!SWIG_IsOK(res1)) {
32710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32711 }
32712 arg1 = reinterpret_cast< wxWindow * >(argp1);
32713 {
32714 PyThreadState* __tstate = wxPyBeginAllowThreads();
32715 result = (PyObject *)wxWindow_GetChildren(arg1);
32716 wxPyEndAllowThreads(__tstate);
32717 if (PyErr_Occurred()) SWIG_fail;
32718 }
32719 resultobj = result;
32720 return resultobj;
32721 fail:
32722 return NULL;
32723 }
32724
32725
32726 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32727 PyObject *resultobj = 0;
32728 wxWindow *arg1 = (wxWindow *) 0 ;
32729 wxWindow *result = 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_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32739 }
32740 arg1 = reinterpret_cast< wxWindow * >(argp1);
32741 {
32742 PyThreadState* __tstate = wxPyBeginAllowThreads();
32743 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32744 wxPyEndAllowThreads(__tstate);
32745 if (PyErr_Occurred()) SWIG_fail;
32746 }
32747 {
32748 resultobj = wxPyMake_wxObject(result, 0);
32749 }
32750 return resultobj;
32751 fail:
32752 return NULL;
32753 }
32754
32755
32756 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32757 PyObject *resultobj = 0;
32758 wxWindow *arg1 = (wxWindow *) 0 ;
32759 wxWindow *result = 0 ;
32760 void *argp1 = 0 ;
32761 int res1 = 0 ;
32762 PyObject *swig_obj[1] ;
32763
32764 if (!args) SWIG_fail;
32765 swig_obj[0] = args;
32766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32767 if (!SWIG_IsOK(res1)) {
32768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32769 }
32770 arg1 = reinterpret_cast< wxWindow * >(argp1);
32771 {
32772 PyThreadState* __tstate = wxPyBeginAllowThreads();
32773 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32774 wxPyEndAllowThreads(__tstate);
32775 if (PyErr_Occurred()) SWIG_fail;
32776 }
32777 {
32778 resultobj = wxPyMake_wxObject(result, 0);
32779 }
32780 return resultobj;
32781 fail:
32782 return NULL;
32783 }
32784
32785
32786 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32787 PyObject *resultobj = 0;
32788 wxWindow *arg1 = (wxWindow *) 0 ;
32789 bool result;
32790 void *argp1 = 0 ;
32791 int res1 = 0 ;
32792 PyObject *swig_obj[1] ;
32793
32794 if (!args) SWIG_fail;
32795 swig_obj[0] = args;
32796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32797 if (!SWIG_IsOK(res1)) {
32798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
32799 }
32800 arg1 = reinterpret_cast< wxWindow * >(argp1);
32801 {
32802 PyThreadState* __tstate = wxPyBeginAllowThreads();
32803 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
32804 wxPyEndAllowThreads(__tstate);
32805 if (PyErr_Occurred()) SWIG_fail;
32806 }
32807 {
32808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32809 }
32810 return resultobj;
32811 fail:
32812 return NULL;
32813 }
32814
32815
32816 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32817 PyObject *resultobj = 0;
32818 wxWindow *arg1 = (wxWindow *) 0 ;
32819 wxWindow *arg2 = (wxWindow *) 0 ;
32820 bool result;
32821 void *argp1 = 0 ;
32822 int res1 = 0 ;
32823 void *argp2 = 0 ;
32824 int res2 = 0 ;
32825 PyObject * obj0 = 0 ;
32826 PyObject * obj1 = 0 ;
32827 char * kwnames[] = {
32828 (char *) "self",(char *) "newParent", NULL
32829 };
32830
32831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
32832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32833 if (!SWIG_IsOK(res1)) {
32834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
32835 }
32836 arg1 = reinterpret_cast< wxWindow * >(argp1);
32837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32838 if (!SWIG_IsOK(res2)) {
32839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
32840 }
32841 arg2 = reinterpret_cast< wxWindow * >(argp2);
32842 {
32843 PyThreadState* __tstate = wxPyBeginAllowThreads();
32844 result = (bool)(arg1)->Reparent(arg2);
32845 wxPyEndAllowThreads(__tstate);
32846 if (PyErr_Occurred()) SWIG_fail;
32847 }
32848 {
32849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32850 }
32851 return resultobj;
32852 fail:
32853 return NULL;
32854 }
32855
32856
32857 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32858 PyObject *resultobj = 0;
32859 wxWindow *arg1 = (wxWindow *) 0 ;
32860 wxWindow *arg2 = (wxWindow *) 0 ;
32861 void *argp1 = 0 ;
32862 int res1 = 0 ;
32863 void *argp2 = 0 ;
32864 int res2 = 0 ;
32865 PyObject * obj0 = 0 ;
32866 PyObject * obj1 = 0 ;
32867 char * kwnames[] = {
32868 (char *) "self",(char *) "child", NULL
32869 };
32870
32871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
32872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32873 if (!SWIG_IsOK(res1)) {
32874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
32875 }
32876 arg1 = reinterpret_cast< wxWindow * >(argp1);
32877 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32878 if (!SWIG_IsOK(res2)) {
32879 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
32880 }
32881 arg2 = reinterpret_cast< wxWindow * >(argp2);
32882 {
32883 PyThreadState* __tstate = wxPyBeginAllowThreads();
32884 (arg1)->AddChild(arg2);
32885 wxPyEndAllowThreads(__tstate);
32886 if (PyErr_Occurred()) SWIG_fail;
32887 }
32888 resultobj = SWIG_Py_Void();
32889 return resultobj;
32890 fail:
32891 return NULL;
32892 }
32893
32894
32895 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32896 PyObject *resultobj = 0;
32897 wxWindow *arg1 = (wxWindow *) 0 ;
32898 wxWindow *arg2 = (wxWindow *) 0 ;
32899 void *argp1 = 0 ;
32900 int res1 = 0 ;
32901 void *argp2 = 0 ;
32902 int res2 = 0 ;
32903 PyObject * obj0 = 0 ;
32904 PyObject * obj1 = 0 ;
32905 char * kwnames[] = {
32906 (char *) "self",(char *) "child", NULL
32907 };
32908
32909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
32910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32911 if (!SWIG_IsOK(res1)) {
32912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
32913 }
32914 arg1 = reinterpret_cast< wxWindow * >(argp1);
32915 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32916 if (!SWIG_IsOK(res2)) {
32917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
32918 }
32919 arg2 = reinterpret_cast< wxWindow * >(argp2);
32920 {
32921 PyThreadState* __tstate = wxPyBeginAllowThreads();
32922 (arg1)->RemoveChild(arg2);
32923 wxPyEndAllowThreads(__tstate);
32924 if (PyErr_Occurred()) SWIG_fail;
32925 }
32926 resultobj = SWIG_Py_Void();
32927 return resultobj;
32928 fail:
32929 return NULL;
32930 }
32931
32932
32933 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32934 PyObject *resultobj = 0;
32935 wxWindow *arg1 = (wxWindow *) 0 ;
32936 long arg2 ;
32937 wxWindow *result = 0 ;
32938 void *argp1 = 0 ;
32939 int res1 = 0 ;
32940 long val2 ;
32941 int ecode2 = 0 ;
32942 PyObject * obj0 = 0 ;
32943 PyObject * obj1 = 0 ;
32944 char * kwnames[] = {
32945 (char *) "self",(char *) "winid", NULL
32946 };
32947
32948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
32949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32950 if (!SWIG_IsOK(res1)) {
32951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
32952 }
32953 arg1 = reinterpret_cast< wxWindow * >(argp1);
32954 ecode2 = SWIG_AsVal_long(obj1, &val2);
32955 if (!SWIG_IsOK(ecode2)) {
32956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
32957 }
32958 arg2 = static_cast< long >(val2);
32959 {
32960 PyThreadState* __tstate = wxPyBeginAllowThreads();
32961 result = (wxWindow *)(arg1)->FindWindow(arg2);
32962 wxPyEndAllowThreads(__tstate);
32963 if (PyErr_Occurred()) SWIG_fail;
32964 }
32965 {
32966 resultobj = wxPyMake_wxObject(result, 0);
32967 }
32968 return resultobj;
32969 fail:
32970 return NULL;
32971 }
32972
32973
32974 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32975 PyObject *resultobj = 0;
32976 wxWindow *arg1 = (wxWindow *) 0 ;
32977 wxString *arg2 = 0 ;
32978 wxWindow *result = 0 ;
32979 void *argp1 = 0 ;
32980 int res1 = 0 ;
32981 bool temp2 = false ;
32982 PyObject * obj0 = 0 ;
32983 PyObject * obj1 = 0 ;
32984 char * kwnames[] = {
32985 (char *) "self",(char *) "name", NULL
32986 };
32987
32988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
32989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32990 if (!SWIG_IsOK(res1)) {
32991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
32992 }
32993 arg1 = reinterpret_cast< wxWindow * >(argp1);
32994 {
32995 arg2 = wxString_in_helper(obj1);
32996 if (arg2 == NULL) SWIG_fail;
32997 temp2 = true;
32998 }
32999 {
33000 PyThreadState* __tstate = wxPyBeginAllowThreads();
33001 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33002 wxPyEndAllowThreads(__tstate);
33003 if (PyErr_Occurred()) SWIG_fail;
33004 }
33005 {
33006 resultobj = wxPyMake_wxObject(result, 0);
33007 }
33008 {
33009 if (temp2)
33010 delete arg2;
33011 }
33012 return resultobj;
33013 fail:
33014 {
33015 if (temp2)
33016 delete arg2;
33017 }
33018 return NULL;
33019 }
33020
33021
33022 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33023 PyObject *resultobj = 0;
33024 wxWindow *arg1 = (wxWindow *) 0 ;
33025 wxEvtHandler *result = 0 ;
33026 void *argp1 = 0 ;
33027 int res1 = 0 ;
33028 PyObject *swig_obj[1] ;
33029
33030 if (!args) SWIG_fail;
33031 swig_obj[0] = args;
33032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33033 if (!SWIG_IsOK(res1)) {
33034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33035 }
33036 arg1 = reinterpret_cast< wxWindow * >(argp1);
33037 {
33038 PyThreadState* __tstate = wxPyBeginAllowThreads();
33039 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33040 wxPyEndAllowThreads(__tstate);
33041 if (PyErr_Occurred()) SWIG_fail;
33042 }
33043 {
33044 resultobj = wxPyMake_wxObject(result, 0);
33045 }
33046 return resultobj;
33047 fail:
33048 return NULL;
33049 }
33050
33051
33052 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33053 PyObject *resultobj = 0;
33054 wxWindow *arg1 = (wxWindow *) 0 ;
33055 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33056 void *argp1 = 0 ;
33057 int res1 = 0 ;
33058 void *argp2 = 0 ;
33059 int res2 = 0 ;
33060 PyObject * obj0 = 0 ;
33061 PyObject * obj1 = 0 ;
33062 char * kwnames[] = {
33063 (char *) "self",(char *) "handler", NULL
33064 };
33065
33066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33068 if (!SWIG_IsOK(res1)) {
33069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33070 }
33071 arg1 = reinterpret_cast< wxWindow * >(argp1);
33072 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33073 if (!SWIG_IsOK(res2)) {
33074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33075 }
33076 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33077 {
33078 PyThreadState* __tstate = wxPyBeginAllowThreads();
33079 (arg1)->SetEventHandler(arg2);
33080 wxPyEndAllowThreads(__tstate);
33081 if (PyErr_Occurred()) SWIG_fail;
33082 }
33083 resultobj = SWIG_Py_Void();
33084 return resultobj;
33085 fail:
33086 return NULL;
33087 }
33088
33089
33090 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33091 PyObject *resultobj = 0;
33092 wxWindow *arg1 = (wxWindow *) 0 ;
33093 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33094 void *argp1 = 0 ;
33095 int res1 = 0 ;
33096 void *argp2 = 0 ;
33097 int res2 = 0 ;
33098 PyObject * obj0 = 0 ;
33099 PyObject * obj1 = 0 ;
33100 char * kwnames[] = {
33101 (char *) "self",(char *) "handler", NULL
33102 };
33103
33104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33106 if (!SWIG_IsOK(res1)) {
33107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33108 }
33109 arg1 = reinterpret_cast< wxWindow * >(argp1);
33110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33111 if (!SWIG_IsOK(res2)) {
33112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33113 }
33114 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33115 {
33116 PyThreadState* __tstate = wxPyBeginAllowThreads();
33117 (arg1)->PushEventHandler(arg2);
33118 wxPyEndAllowThreads(__tstate);
33119 if (PyErr_Occurred()) SWIG_fail;
33120 }
33121 resultobj = SWIG_Py_Void();
33122 return resultobj;
33123 fail:
33124 return NULL;
33125 }
33126
33127
33128 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33129 PyObject *resultobj = 0;
33130 wxWindow *arg1 = (wxWindow *) 0 ;
33131 bool arg2 = (bool) false ;
33132 wxEvtHandler *result = 0 ;
33133 void *argp1 = 0 ;
33134 int res1 = 0 ;
33135 bool val2 ;
33136 int ecode2 = 0 ;
33137 PyObject * obj0 = 0 ;
33138 PyObject * obj1 = 0 ;
33139 char * kwnames[] = {
33140 (char *) "self",(char *) "deleteHandler", NULL
33141 };
33142
33143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33145 if (!SWIG_IsOK(res1)) {
33146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33147 }
33148 arg1 = reinterpret_cast< wxWindow * >(argp1);
33149 if (obj1) {
33150 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33151 if (!SWIG_IsOK(ecode2)) {
33152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33153 }
33154 arg2 = static_cast< bool >(val2);
33155 }
33156 {
33157 PyThreadState* __tstate = wxPyBeginAllowThreads();
33158 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33159 wxPyEndAllowThreads(__tstate);
33160 if (PyErr_Occurred()) SWIG_fail;
33161 }
33162 {
33163 resultobj = wxPyMake_wxObject(result, 0);
33164 }
33165 return resultobj;
33166 fail:
33167 return NULL;
33168 }
33169
33170
33171 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33172 PyObject *resultobj = 0;
33173 wxWindow *arg1 = (wxWindow *) 0 ;
33174 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33175 bool result;
33176 void *argp1 = 0 ;
33177 int res1 = 0 ;
33178 void *argp2 = 0 ;
33179 int res2 = 0 ;
33180 PyObject * obj0 = 0 ;
33181 PyObject * obj1 = 0 ;
33182 char * kwnames[] = {
33183 (char *) "self",(char *) "handler", NULL
33184 };
33185
33186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33188 if (!SWIG_IsOK(res1)) {
33189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33190 }
33191 arg1 = reinterpret_cast< wxWindow * >(argp1);
33192 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33193 if (!SWIG_IsOK(res2)) {
33194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33195 }
33196 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33197 {
33198 PyThreadState* __tstate = wxPyBeginAllowThreads();
33199 result = (bool)(arg1)->RemoveEventHandler(arg2);
33200 wxPyEndAllowThreads(__tstate);
33201 if (PyErr_Occurred()) SWIG_fail;
33202 }
33203 {
33204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33205 }
33206 return resultobj;
33207 fail:
33208 return NULL;
33209 }
33210
33211
33212 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33213 PyObject *resultobj = 0;
33214 wxWindow *arg1 = (wxWindow *) 0 ;
33215 wxValidator *arg2 = 0 ;
33216 void *argp1 = 0 ;
33217 int res1 = 0 ;
33218 void *argp2 = 0 ;
33219 int res2 = 0 ;
33220 PyObject * obj0 = 0 ;
33221 PyObject * obj1 = 0 ;
33222 char * kwnames[] = {
33223 (char *) "self",(char *) "validator", NULL
33224 };
33225
33226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33228 if (!SWIG_IsOK(res1)) {
33229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33230 }
33231 arg1 = reinterpret_cast< wxWindow * >(argp1);
33232 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33233 if (!SWIG_IsOK(res2)) {
33234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33235 }
33236 if (!argp2) {
33237 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33238 }
33239 arg2 = reinterpret_cast< wxValidator * >(argp2);
33240 {
33241 PyThreadState* __tstate = wxPyBeginAllowThreads();
33242 (arg1)->SetValidator((wxValidator const &)*arg2);
33243 wxPyEndAllowThreads(__tstate);
33244 if (PyErr_Occurred()) SWIG_fail;
33245 }
33246 resultobj = SWIG_Py_Void();
33247 return resultobj;
33248 fail:
33249 return NULL;
33250 }
33251
33252
33253 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33254 PyObject *resultobj = 0;
33255 wxWindow *arg1 = (wxWindow *) 0 ;
33256 wxValidator *result = 0 ;
33257 void *argp1 = 0 ;
33258 int res1 = 0 ;
33259 PyObject *swig_obj[1] ;
33260
33261 if (!args) SWIG_fail;
33262 swig_obj[0] = args;
33263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33264 if (!SWIG_IsOK(res1)) {
33265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33266 }
33267 arg1 = reinterpret_cast< wxWindow * >(argp1);
33268 {
33269 PyThreadState* __tstate = wxPyBeginAllowThreads();
33270 result = (wxValidator *)(arg1)->GetValidator();
33271 wxPyEndAllowThreads(__tstate);
33272 if (PyErr_Occurred()) SWIG_fail;
33273 }
33274 {
33275 resultobj = wxPyMake_wxObject(result, (bool)0);
33276 }
33277 return resultobj;
33278 fail:
33279 return NULL;
33280 }
33281
33282
33283 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33284 PyObject *resultobj = 0;
33285 wxWindow *arg1 = (wxWindow *) 0 ;
33286 bool result;
33287 void *argp1 = 0 ;
33288 int res1 = 0 ;
33289 PyObject *swig_obj[1] ;
33290
33291 if (!args) SWIG_fail;
33292 swig_obj[0] = args;
33293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33294 if (!SWIG_IsOK(res1)) {
33295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33296 }
33297 arg1 = reinterpret_cast< wxWindow * >(argp1);
33298 {
33299 PyThreadState* __tstate = wxPyBeginAllowThreads();
33300 result = (bool)(arg1)->Validate();
33301 wxPyEndAllowThreads(__tstate);
33302 if (PyErr_Occurred()) SWIG_fail;
33303 }
33304 {
33305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33306 }
33307 return resultobj;
33308 fail:
33309 return NULL;
33310 }
33311
33312
33313 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33314 PyObject *resultobj = 0;
33315 wxWindow *arg1 = (wxWindow *) 0 ;
33316 bool result;
33317 void *argp1 = 0 ;
33318 int res1 = 0 ;
33319 PyObject *swig_obj[1] ;
33320
33321 if (!args) SWIG_fail;
33322 swig_obj[0] = args;
33323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33324 if (!SWIG_IsOK(res1)) {
33325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33326 }
33327 arg1 = reinterpret_cast< wxWindow * >(argp1);
33328 {
33329 PyThreadState* __tstate = wxPyBeginAllowThreads();
33330 result = (bool)(arg1)->TransferDataToWindow();
33331 wxPyEndAllowThreads(__tstate);
33332 if (PyErr_Occurred()) SWIG_fail;
33333 }
33334 {
33335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33336 }
33337 return resultobj;
33338 fail:
33339 return NULL;
33340 }
33341
33342
33343 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33344 PyObject *resultobj = 0;
33345 wxWindow *arg1 = (wxWindow *) 0 ;
33346 bool result;
33347 void *argp1 = 0 ;
33348 int res1 = 0 ;
33349 PyObject *swig_obj[1] ;
33350
33351 if (!args) SWIG_fail;
33352 swig_obj[0] = args;
33353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33354 if (!SWIG_IsOK(res1)) {
33355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33356 }
33357 arg1 = reinterpret_cast< wxWindow * >(argp1);
33358 {
33359 PyThreadState* __tstate = wxPyBeginAllowThreads();
33360 result = (bool)(arg1)->TransferDataFromWindow();
33361 wxPyEndAllowThreads(__tstate);
33362 if (PyErr_Occurred()) SWIG_fail;
33363 }
33364 {
33365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33366 }
33367 return resultobj;
33368 fail:
33369 return NULL;
33370 }
33371
33372
33373 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33374 PyObject *resultobj = 0;
33375 wxWindow *arg1 = (wxWindow *) 0 ;
33376 void *argp1 = 0 ;
33377 int res1 = 0 ;
33378 PyObject *swig_obj[1] ;
33379
33380 if (!args) SWIG_fail;
33381 swig_obj[0] = args;
33382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33383 if (!SWIG_IsOK(res1)) {
33384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33385 }
33386 arg1 = reinterpret_cast< wxWindow * >(argp1);
33387 {
33388 PyThreadState* __tstate = wxPyBeginAllowThreads();
33389 (arg1)->InitDialog();
33390 wxPyEndAllowThreads(__tstate);
33391 if (PyErr_Occurred()) SWIG_fail;
33392 }
33393 resultobj = SWIG_Py_Void();
33394 return resultobj;
33395 fail:
33396 return NULL;
33397 }
33398
33399
33400 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33401 PyObject *resultobj = 0;
33402 wxWindow *arg1 = (wxWindow *) 0 ;
33403 wxAcceleratorTable *arg2 = 0 ;
33404 void *argp1 = 0 ;
33405 int res1 = 0 ;
33406 void *argp2 = 0 ;
33407 int res2 = 0 ;
33408 PyObject * obj0 = 0 ;
33409 PyObject * obj1 = 0 ;
33410 char * kwnames[] = {
33411 (char *) "self",(char *) "accel", NULL
33412 };
33413
33414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33416 if (!SWIG_IsOK(res1)) {
33417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33418 }
33419 arg1 = reinterpret_cast< wxWindow * >(argp1);
33420 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33421 if (!SWIG_IsOK(res2)) {
33422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33423 }
33424 if (!argp2) {
33425 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33426 }
33427 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33428 {
33429 PyThreadState* __tstate = wxPyBeginAllowThreads();
33430 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33431 wxPyEndAllowThreads(__tstate);
33432 if (PyErr_Occurred()) SWIG_fail;
33433 }
33434 resultobj = SWIG_Py_Void();
33435 return resultobj;
33436 fail:
33437 return NULL;
33438 }
33439
33440
33441 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33442 PyObject *resultobj = 0;
33443 wxWindow *arg1 = (wxWindow *) 0 ;
33444 wxAcceleratorTable *result = 0 ;
33445 void *argp1 = 0 ;
33446 int res1 = 0 ;
33447 PyObject *swig_obj[1] ;
33448
33449 if (!args) SWIG_fail;
33450 swig_obj[0] = args;
33451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33452 if (!SWIG_IsOK(res1)) {
33453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33454 }
33455 arg1 = reinterpret_cast< wxWindow * >(argp1);
33456 {
33457 PyThreadState* __tstate = wxPyBeginAllowThreads();
33458 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33459 wxPyEndAllowThreads(__tstate);
33460 if (PyErr_Occurred()) SWIG_fail;
33461 }
33462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33463 return resultobj;
33464 fail:
33465 return NULL;
33466 }
33467
33468
33469 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33470 PyObject *resultobj = 0;
33471 wxWindow *arg1 = (wxWindow *) 0 ;
33472 int arg2 ;
33473 int arg3 ;
33474 int arg4 ;
33475 bool result;
33476 void *argp1 = 0 ;
33477 int res1 = 0 ;
33478 int val2 ;
33479 int ecode2 = 0 ;
33480 int val3 ;
33481 int ecode3 = 0 ;
33482 int val4 ;
33483 int ecode4 = 0 ;
33484 PyObject * obj0 = 0 ;
33485 PyObject * obj1 = 0 ;
33486 PyObject * obj2 = 0 ;
33487 PyObject * obj3 = 0 ;
33488 char * kwnames[] = {
33489 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33490 };
33491
33492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33494 if (!SWIG_IsOK(res1)) {
33495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33496 }
33497 arg1 = reinterpret_cast< wxWindow * >(argp1);
33498 ecode2 = SWIG_AsVal_int(obj1, &val2);
33499 if (!SWIG_IsOK(ecode2)) {
33500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33501 }
33502 arg2 = static_cast< int >(val2);
33503 ecode3 = SWIG_AsVal_int(obj2, &val3);
33504 if (!SWIG_IsOK(ecode3)) {
33505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33506 }
33507 arg3 = static_cast< int >(val3);
33508 ecode4 = SWIG_AsVal_int(obj3, &val4);
33509 if (!SWIG_IsOK(ecode4)) {
33510 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33511 }
33512 arg4 = static_cast< int >(val4);
33513 {
33514 PyThreadState* __tstate = wxPyBeginAllowThreads();
33515 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33516 wxPyEndAllowThreads(__tstate);
33517 if (PyErr_Occurred()) SWIG_fail;
33518 }
33519 {
33520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33521 }
33522 return resultobj;
33523 fail:
33524 return NULL;
33525 }
33526
33527
33528 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33529 PyObject *resultobj = 0;
33530 wxWindow *arg1 = (wxWindow *) 0 ;
33531 int arg2 ;
33532 bool result;
33533 void *argp1 = 0 ;
33534 int res1 = 0 ;
33535 int val2 ;
33536 int ecode2 = 0 ;
33537 PyObject * obj0 = 0 ;
33538 PyObject * obj1 = 0 ;
33539 char * kwnames[] = {
33540 (char *) "self",(char *) "hotkeyId", NULL
33541 };
33542
33543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33545 if (!SWIG_IsOK(res1)) {
33546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33547 }
33548 arg1 = reinterpret_cast< wxWindow * >(argp1);
33549 ecode2 = SWIG_AsVal_int(obj1, &val2);
33550 if (!SWIG_IsOK(ecode2)) {
33551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33552 }
33553 arg2 = static_cast< int >(val2);
33554 {
33555 PyThreadState* __tstate = wxPyBeginAllowThreads();
33556 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33557 wxPyEndAllowThreads(__tstate);
33558 if (PyErr_Occurred()) SWIG_fail;
33559 }
33560 {
33561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33562 }
33563 return resultobj;
33564 fail:
33565 return NULL;
33566 }
33567
33568
33569 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33570 PyObject *resultobj = 0;
33571 wxWindow *arg1 = (wxWindow *) 0 ;
33572 wxPoint *arg2 = 0 ;
33573 wxPoint result;
33574 void *argp1 = 0 ;
33575 int res1 = 0 ;
33576 wxPoint temp2 ;
33577 PyObject * obj0 = 0 ;
33578 PyObject * obj1 = 0 ;
33579 char * kwnames[] = {
33580 (char *) "self",(char *) "pt", NULL
33581 };
33582
33583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33585 if (!SWIG_IsOK(res1)) {
33586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33587 }
33588 arg1 = reinterpret_cast< wxWindow * >(argp1);
33589 {
33590 arg2 = &temp2;
33591 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33592 }
33593 {
33594 PyThreadState* __tstate = wxPyBeginAllowThreads();
33595 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33596 wxPyEndAllowThreads(__tstate);
33597 if (PyErr_Occurred()) SWIG_fail;
33598 }
33599 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33600 return resultobj;
33601 fail:
33602 return NULL;
33603 }
33604
33605
33606 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33607 PyObject *resultobj = 0;
33608 wxWindow *arg1 = (wxWindow *) 0 ;
33609 wxSize *arg2 = 0 ;
33610 wxSize result;
33611 void *argp1 = 0 ;
33612 int res1 = 0 ;
33613 wxSize temp2 ;
33614 PyObject * obj0 = 0 ;
33615 PyObject * obj1 = 0 ;
33616 char * kwnames[] = {
33617 (char *) "self",(char *) "sz", NULL
33618 };
33619
33620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33622 if (!SWIG_IsOK(res1)) {
33623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33624 }
33625 arg1 = reinterpret_cast< wxWindow * >(argp1);
33626 {
33627 arg2 = &temp2;
33628 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33629 }
33630 {
33631 PyThreadState* __tstate = wxPyBeginAllowThreads();
33632 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33633 wxPyEndAllowThreads(__tstate);
33634 if (PyErr_Occurred()) SWIG_fail;
33635 }
33636 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33637 return resultobj;
33638 fail:
33639 return NULL;
33640 }
33641
33642
33643 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33644 PyObject *resultobj = 0;
33645 wxWindow *arg1 = (wxWindow *) 0 ;
33646 wxPoint *arg2 = 0 ;
33647 wxPoint result;
33648 void *argp1 = 0 ;
33649 int res1 = 0 ;
33650 wxPoint temp2 ;
33651 PyObject * obj0 = 0 ;
33652 PyObject * obj1 = 0 ;
33653 char * kwnames[] = {
33654 (char *) "self",(char *) "pt", NULL
33655 };
33656
33657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33659 if (!SWIG_IsOK(res1)) {
33660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33661 }
33662 arg1 = reinterpret_cast< wxWindow * >(argp1);
33663 {
33664 arg2 = &temp2;
33665 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33666 }
33667 {
33668 PyThreadState* __tstate = wxPyBeginAllowThreads();
33669 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33670 wxPyEndAllowThreads(__tstate);
33671 if (PyErr_Occurred()) SWIG_fail;
33672 }
33673 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33674 return resultobj;
33675 fail:
33676 return NULL;
33677 }
33678
33679
33680 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33681 PyObject *resultobj = 0;
33682 wxWindow *arg1 = (wxWindow *) 0 ;
33683 wxSize *arg2 = 0 ;
33684 wxSize result;
33685 void *argp1 = 0 ;
33686 int res1 = 0 ;
33687 wxSize temp2 ;
33688 PyObject * obj0 = 0 ;
33689 PyObject * obj1 = 0 ;
33690 char * kwnames[] = {
33691 (char *) "self",(char *) "sz", NULL
33692 };
33693
33694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33696 if (!SWIG_IsOK(res1)) {
33697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33698 }
33699 arg1 = reinterpret_cast< wxWindow * >(argp1);
33700 {
33701 arg2 = &temp2;
33702 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33703 }
33704 {
33705 PyThreadState* __tstate = wxPyBeginAllowThreads();
33706 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33707 wxPyEndAllowThreads(__tstate);
33708 if (PyErr_Occurred()) SWIG_fail;
33709 }
33710 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33711 return resultobj;
33712 fail:
33713 return NULL;
33714 }
33715
33716
33717 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33718 PyObject *resultobj = 0;
33719 wxWindow *arg1 = (wxWindow *) 0 ;
33720 wxPoint *arg2 = 0 ;
33721 wxPoint result;
33722 void *argp1 = 0 ;
33723 int res1 = 0 ;
33724 wxPoint temp2 ;
33725 PyObject * obj0 = 0 ;
33726 PyObject * obj1 = 0 ;
33727 char * kwnames[] = {
33728 (char *) "self",(char *) "pt", NULL
33729 };
33730
33731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33733 if (!SWIG_IsOK(res1)) {
33734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33735 }
33736 arg1 = reinterpret_cast< wxWindow * >(argp1);
33737 {
33738 arg2 = &temp2;
33739 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33740 }
33741 {
33742 PyThreadState* __tstate = wxPyBeginAllowThreads();
33743 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33744 wxPyEndAllowThreads(__tstate);
33745 if (PyErr_Occurred()) SWIG_fail;
33746 }
33747 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33748 return resultobj;
33749 fail:
33750 return NULL;
33751 }
33752
33753
33754 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33755 PyObject *resultobj = 0;
33756 wxWindow *arg1 = (wxWindow *) 0 ;
33757 wxSize *arg2 = 0 ;
33758 wxSize result;
33759 void *argp1 = 0 ;
33760 int res1 = 0 ;
33761 wxSize temp2 ;
33762 PyObject * obj0 = 0 ;
33763 PyObject * obj1 = 0 ;
33764 char * kwnames[] = {
33765 (char *) "self",(char *) "sz", NULL
33766 };
33767
33768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33770 if (!SWIG_IsOK(res1)) {
33771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33772 }
33773 arg1 = reinterpret_cast< wxWindow * >(argp1);
33774 {
33775 arg2 = &temp2;
33776 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33777 }
33778 {
33779 PyThreadState* __tstate = wxPyBeginAllowThreads();
33780 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33781 wxPyEndAllowThreads(__tstate);
33782 if (PyErr_Occurred()) SWIG_fail;
33783 }
33784 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33785 return resultobj;
33786 fail:
33787 return NULL;
33788 }
33789
33790
33791 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33792 PyObject *resultobj = 0;
33793 wxWindow *arg1 = (wxWindow *) 0 ;
33794 int arg2 ;
33795 int arg3 ;
33796 void *argp1 = 0 ;
33797 int res1 = 0 ;
33798 int val2 ;
33799 int ecode2 = 0 ;
33800 int val3 ;
33801 int ecode3 = 0 ;
33802 PyObject * obj0 = 0 ;
33803 PyObject * obj1 = 0 ;
33804 PyObject * obj2 = 0 ;
33805 char * kwnames[] = {
33806 (char *) "self",(char *) "x",(char *) "y", NULL
33807 };
33808
33809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33811 if (!SWIG_IsOK(res1)) {
33812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
33813 }
33814 arg1 = reinterpret_cast< wxWindow * >(argp1);
33815 ecode2 = SWIG_AsVal_int(obj1, &val2);
33816 if (!SWIG_IsOK(ecode2)) {
33817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
33818 }
33819 arg2 = static_cast< int >(val2);
33820 ecode3 = SWIG_AsVal_int(obj2, &val3);
33821 if (!SWIG_IsOK(ecode3)) {
33822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
33823 }
33824 arg3 = static_cast< int >(val3);
33825 {
33826 PyThreadState* __tstate = wxPyBeginAllowThreads();
33827 (arg1)->WarpPointer(arg2,arg3);
33828 wxPyEndAllowThreads(__tstate);
33829 if (PyErr_Occurred()) SWIG_fail;
33830 }
33831 resultobj = SWIG_Py_Void();
33832 return resultobj;
33833 fail:
33834 return NULL;
33835 }
33836
33837
33838 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33839 PyObject *resultobj = 0;
33840 wxWindow *arg1 = (wxWindow *) 0 ;
33841 void *argp1 = 0 ;
33842 int res1 = 0 ;
33843 PyObject *swig_obj[1] ;
33844
33845 if (!args) SWIG_fail;
33846 swig_obj[0] = args;
33847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33848 if (!SWIG_IsOK(res1)) {
33849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
33850 }
33851 arg1 = reinterpret_cast< wxWindow * >(argp1);
33852 {
33853 PyThreadState* __tstate = wxPyBeginAllowThreads();
33854 (arg1)->CaptureMouse();
33855 wxPyEndAllowThreads(__tstate);
33856 if (PyErr_Occurred()) SWIG_fail;
33857 }
33858 resultobj = SWIG_Py_Void();
33859 return resultobj;
33860 fail:
33861 return NULL;
33862 }
33863
33864
33865 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33866 PyObject *resultobj = 0;
33867 wxWindow *arg1 = (wxWindow *) 0 ;
33868 void *argp1 = 0 ;
33869 int res1 = 0 ;
33870 PyObject *swig_obj[1] ;
33871
33872 if (!args) SWIG_fail;
33873 swig_obj[0] = args;
33874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33875 if (!SWIG_IsOK(res1)) {
33876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
33877 }
33878 arg1 = reinterpret_cast< wxWindow * >(argp1);
33879 {
33880 PyThreadState* __tstate = wxPyBeginAllowThreads();
33881 (arg1)->ReleaseMouse();
33882 wxPyEndAllowThreads(__tstate);
33883 if (PyErr_Occurred()) SWIG_fail;
33884 }
33885 resultobj = SWIG_Py_Void();
33886 return resultobj;
33887 fail:
33888 return NULL;
33889 }
33890
33891
33892 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33893 PyObject *resultobj = 0;
33894 wxWindow *result = 0 ;
33895
33896 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
33897 {
33898 if (!wxPyCheckForApp()) SWIG_fail;
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 result = (wxWindow *)wxWindow::GetCapture();
33901 wxPyEndAllowThreads(__tstate);
33902 if (PyErr_Occurred()) SWIG_fail;
33903 }
33904 {
33905 resultobj = wxPyMake_wxObject(result, 0);
33906 }
33907 return resultobj;
33908 fail:
33909 return NULL;
33910 }
33911
33912
33913 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33914 PyObject *resultobj = 0;
33915 wxWindow *arg1 = (wxWindow *) 0 ;
33916 bool result;
33917 void *argp1 = 0 ;
33918 int res1 = 0 ;
33919 PyObject *swig_obj[1] ;
33920
33921 if (!args) SWIG_fail;
33922 swig_obj[0] = args;
33923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33924 if (!SWIG_IsOK(res1)) {
33925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
33926 }
33927 arg1 = reinterpret_cast< wxWindow * >(argp1);
33928 {
33929 PyThreadState* __tstate = wxPyBeginAllowThreads();
33930 result = (bool)((wxWindow const *)arg1)->HasCapture();
33931 wxPyEndAllowThreads(__tstate);
33932 if (PyErr_Occurred()) SWIG_fail;
33933 }
33934 {
33935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33936 }
33937 return resultobj;
33938 fail:
33939 return NULL;
33940 }
33941
33942
33943 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33944 PyObject *resultobj = 0;
33945 wxWindow *arg1 = (wxWindow *) 0 ;
33946 bool arg2 = (bool) true ;
33947 wxRect *arg3 = (wxRect *) NULL ;
33948 void *argp1 = 0 ;
33949 int res1 = 0 ;
33950 bool val2 ;
33951 int ecode2 = 0 ;
33952 void *argp3 = 0 ;
33953 int res3 = 0 ;
33954 PyObject * obj0 = 0 ;
33955 PyObject * obj1 = 0 ;
33956 PyObject * obj2 = 0 ;
33957 char * kwnames[] = {
33958 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
33959 };
33960
33961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33963 if (!SWIG_IsOK(res1)) {
33964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
33965 }
33966 arg1 = reinterpret_cast< wxWindow * >(argp1);
33967 if (obj1) {
33968 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33969 if (!SWIG_IsOK(ecode2)) {
33970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
33971 }
33972 arg2 = static_cast< bool >(val2);
33973 }
33974 if (obj2) {
33975 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
33976 if (!SWIG_IsOK(res3)) {
33977 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
33978 }
33979 arg3 = reinterpret_cast< wxRect * >(argp3);
33980 }
33981 {
33982 PyThreadState* __tstate = wxPyBeginAllowThreads();
33983 (arg1)->Refresh(arg2,(wxRect const *)arg3);
33984 wxPyEndAllowThreads(__tstate);
33985 if (PyErr_Occurred()) SWIG_fail;
33986 }
33987 resultobj = SWIG_Py_Void();
33988 return resultobj;
33989 fail:
33990 return NULL;
33991 }
33992
33993
33994 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33995 PyObject *resultobj = 0;
33996 wxWindow *arg1 = (wxWindow *) 0 ;
33997 wxRect *arg2 = 0 ;
33998 bool arg3 = (bool) true ;
33999 void *argp1 = 0 ;
34000 int res1 = 0 ;
34001 wxRect temp2 ;
34002 bool val3 ;
34003 int ecode3 = 0 ;
34004 PyObject * obj0 = 0 ;
34005 PyObject * obj1 = 0 ;
34006 PyObject * obj2 = 0 ;
34007 char * kwnames[] = {
34008 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34009 };
34010
34011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34013 if (!SWIG_IsOK(res1)) {
34014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34015 }
34016 arg1 = reinterpret_cast< wxWindow * >(argp1);
34017 {
34018 arg2 = &temp2;
34019 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34020 }
34021 if (obj2) {
34022 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34023 if (!SWIG_IsOK(ecode3)) {
34024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34025 }
34026 arg3 = static_cast< bool >(val3);
34027 }
34028 {
34029 PyThreadState* __tstate = wxPyBeginAllowThreads();
34030 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34031 wxPyEndAllowThreads(__tstate);
34032 if (PyErr_Occurred()) SWIG_fail;
34033 }
34034 resultobj = SWIG_Py_Void();
34035 return resultobj;
34036 fail:
34037 return NULL;
34038 }
34039
34040
34041 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34042 PyObject *resultobj = 0;
34043 wxWindow *arg1 = (wxWindow *) 0 ;
34044 void *argp1 = 0 ;
34045 int res1 = 0 ;
34046 PyObject *swig_obj[1] ;
34047
34048 if (!args) SWIG_fail;
34049 swig_obj[0] = args;
34050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34051 if (!SWIG_IsOK(res1)) {
34052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34053 }
34054 arg1 = reinterpret_cast< wxWindow * >(argp1);
34055 {
34056 PyThreadState* __tstate = wxPyBeginAllowThreads();
34057 (arg1)->Update();
34058 wxPyEndAllowThreads(__tstate);
34059 if (PyErr_Occurred()) SWIG_fail;
34060 }
34061 resultobj = SWIG_Py_Void();
34062 return resultobj;
34063 fail:
34064 return NULL;
34065 }
34066
34067
34068 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34069 PyObject *resultobj = 0;
34070 wxWindow *arg1 = (wxWindow *) 0 ;
34071 void *argp1 = 0 ;
34072 int res1 = 0 ;
34073 PyObject *swig_obj[1] ;
34074
34075 if (!args) SWIG_fail;
34076 swig_obj[0] = args;
34077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34078 if (!SWIG_IsOK(res1)) {
34079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34080 }
34081 arg1 = reinterpret_cast< wxWindow * >(argp1);
34082 {
34083 PyThreadState* __tstate = wxPyBeginAllowThreads();
34084 (arg1)->ClearBackground();
34085 wxPyEndAllowThreads(__tstate);
34086 if (PyErr_Occurred()) SWIG_fail;
34087 }
34088 resultobj = SWIG_Py_Void();
34089 return resultobj;
34090 fail:
34091 return NULL;
34092 }
34093
34094
34095 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34096 PyObject *resultobj = 0;
34097 wxWindow *arg1 = (wxWindow *) 0 ;
34098 void *argp1 = 0 ;
34099 int res1 = 0 ;
34100 PyObject *swig_obj[1] ;
34101
34102 if (!args) SWIG_fail;
34103 swig_obj[0] = args;
34104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34105 if (!SWIG_IsOK(res1)) {
34106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34107 }
34108 arg1 = reinterpret_cast< wxWindow * >(argp1);
34109 {
34110 PyThreadState* __tstate = wxPyBeginAllowThreads();
34111 (arg1)->Freeze();
34112 wxPyEndAllowThreads(__tstate);
34113 if (PyErr_Occurred()) SWIG_fail;
34114 }
34115 resultobj = SWIG_Py_Void();
34116 return resultobj;
34117 fail:
34118 return NULL;
34119 }
34120
34121
34122 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34123 PyObject *resultobj = 0;
34124 wxWindow *arg1 = (wxWindow *) 0 ;
34125 void *argp1 = 0 ;
34126 int res1 = 0 ;
34127 PyObject *swig_obj[1] ;
34128
34129 if (!args) SWIG_fail;
34130 swig_obj[0] = args;
34131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34132 if (!SWIG_IsOK(res1)) {
34133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34134 }
34135 arg1 = reinterpret_cast< wxWindow * >(argp1);
34136 {
34137 PyThreadState* __tstate = wxPyBeginAllowThreads();
34138 (arg1)->Thaw();
34139 wxPyEndAllowThreads(__tstate);
34140 if (PyErr_Occurred()) SWIG_fail;
34141 }
34142 resultobj = SWIG_Py_Void();
34143 return resultobj;
34144 fail:
34145 return NULL;
34146 }
34147
34148
34149 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34150 PyObject *resultobj = 0;
34151 wxWindow *arg1 = (wxWindow *) 0 ;
34152 wxDC *arg2 = 0 ;
34153 void *argp1 = 0 ;
34154 int res1 = 0 ;
34155 void *argp2 = 0 ;
34156 int res2 = 0 ;
34157 PyObject * obj0 = 0 ;
34158 PyObject * obj1 = 0 ;
34159 char * kwnames[] = {
34160 (char *) "self",(char *) "dc", NULL
34161 };
34162
34163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34165 if (!SWIG_IsOK(res1)) {
34166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34167 }
34168 arg1 = reinterpret_cast< wxWindow * >(argp1);
34169 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34170 if (!SWIG_IsOK(res2)) {
34171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34172 }
34173 if (!argp2) {
34174 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34175 }
34176 arg2 = reinterpret_cast< wxDC * >(argp2);
34177 {
34178 PyThreadState* __tstate = wxPyBeginAllowThreads();
34179 (arg1)->PrepareDC(*arg2);
34180 wxPyEndAllowThreads(__tstate);
34181 if (PyErr_Occurred()) SWIG_fail;
34182 }
34183 resultobj = SWIG_Py_Void();
34184 return resultobj;
34185 fail:
34186 return NULL;
34187 }
34188
34189
34190 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34191 PyObject *resultobj = 0;
34192 wxWindow *arg1 = (wxWindow *) 0 ;
34193 wxRegion *result = 0 ;
34194 void *argp1 = 0 ;
34195 int res1 = 0 ;
34196 PyObject *swig_obj[1] ;
34197
34198 if (!args) SWIG_fail;
34199 swig_obj[0] = args;
34200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34201 if (!SWIG_IsOK(res1)) {
34202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34203 }
34204 arg1 = reinterpret_cast< wxWindow * >(argp1);
34205 {
34206 PyThreadState* __tstate = wxPyBeginAllowThreads();
34207 {
34208 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34209 result = (wxRegion *) &_result_ref;
34210 }
34211 wxPyEndAllowThreads(__tstate);
34212 if (PyErr_Occurred()) SWIG_fail;
34213 }
34214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34215 return resultobj;
34216 fail:
34217 return NULL;
34218 }
34219
34220
34221 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34222 PyObject *resultobj = 0;
34223 wxWindow *arg1 = (wxWindow *) 0 ;
34224 wxRect result;
34225 void *argp1 = 0 ;
34226 int res1 = 0 ;
34227 PyObject *swig_obj[1] ;
34228
34229 if (!args) SWIG_fail;
34230 swig_obj[0] = args;
34231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34232 if (!SWIG_IsOK(res1)) {
34233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34234 }
34235 arg1 = reinterpret_cast< wxWindow * >(argp1);
34236 {
34237 PyThreadState* __tstate = wxPyBeginAllowThreads();
34238 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34239 wxPyEndAllowThreads(__tstate);
34240 if (PyErr_Occurred()) SWIG_fail;
34241 }
34242 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34243 return resultobj;
34244 fail:
34245 return NULL;
34246 }
34247
34248
34249 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34250 PyObject *resultobj = 0;
34251 wxWindow *arg1 = (wxWindow *) 0 ;
34252 int arg2 ;
34253 int arg3 ;
34254 int arg4 = (int) 1 ;
34255 int arg5 = (int) 1 ;
34256 bool result;
34257 void *argp1 = 0 ;
34258 int res1 = 0 ;
34259 int val2 ;
34260 int ecode2 = 0 ;
34261 int val3 ;
34262 int ecode3 = 0 ;
34263 int val4 ;
34264 int ecode4 = 0 ;
34265 int val5 ;
34266 int ecode5 = 0 ;
34267 PyObject * obj0 = 0 ;
34268 PyObject * obj1 = 0 ;
34269 PyObject * obj2 = 0 ;
34270 PyObject * obj3 = 0 ;
34271 PyObject * obj4 = 0 ;
34272 char * kwnames[] = {
34273 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34274 };
34275
34276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34278 if (!SWIG_IsOK(res1)) {
34279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34280 }
34281 arg1 = reinterpret_cast< wxWindow * >(argp1);
34282 ecode2 = SWIG_AsVal_int(obj1, &val2);
34283 if (!SWIG_IsOK(ecode2)) {
34284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34285 }
34286 arg2 = static_cast< int >(val2);
34287 ecode3 = SWIG_AsVal_int(obj2, &val3);
34288 if (!SWIG_IsOK(ecode3)) {
34289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34290 }
34291 arg3 = static_cast< int >(val3);
34292 if (obj3) {
34293 ecode4 = SWIG_AsVal_int(obj3, &val4);
34294 if (!SWIG_IsOK(ecode4)) {
34295 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34296 }
34297 arg4 = static_cast< int >(val4);
34298 }
34299 if (obj4) {
34300 ecode5 = SWIG_AsVal_int(obj4, &val5);
34301 if (!SWIG_IsOK(ecode5)) {
34302 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34303 }
34304 arg5 = static_cast< int >(val5);
34305 }
34306 {
34307 PyThreadState* __tstate = wxPyBeginAllowThreads();
34308 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34309 wxPyEndAllowThreads(__tstate);
34310 if (PyErr_Occurred()) SWIG_fail;
34311 }
34312 {
34313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34314 }
34315 return resultobj;
34316 fail:
34317 return NULL;
34318 }
34319
34320
34321 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34322 PyObject *resultobj = 0;
34323 wxWindow *arg1 = (wxWindow *) 0 ;
34324 wxPoint *arg2 = 0 ;
34325 bool result;
34326 void *argp1 = 0 ;
34327 int res1 = 0 ;
34328 wxPoint temp2 ;
34329 PyObject * obj0 = 0 ;
34330 PyObject * obj1 = 0 ;
34331 char * kwnames[] = {
34332 (char *) "self",(char *) "pt", NULL
34333 };
34334
34335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34337 if (!SWIG_IsOK(res1)) {
34338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34339 }
34340 arg1 = reinterpret_cast< wxWindow * >(argp1);
34341 {
34342 arg2 = &temp2;
34343 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34344 }
34345 {
34346 PyThreadState* __tstate = wxPyBeginAllowThreads();
34347 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34348 wxPyEndAllowThreads(__tstate);
34349 if (PyErr_Occurred()) SWIG_fail;
34350 }
34351 {
34352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34353 }
34354 return resultobj;
34355 fail:
34356 return NULL;
34357 }
34358
34359
34360 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34361 PyObject *resultobj = 0;
34362 wxWindow *arg1 = (wxWindow *) 0 ;
34363 wxRect *arg2 = 0 ;
34364 bool result;
34365 void *argp1 = 0 ;
34366 int res1 = 0 ;
34367 wxRect temp2 ;
34368 PyObject * obj0 = 0 ;
34369 PyObject * obj1 = 0 ;
34370 char * kwnames[] = {
34371 (char *) "self",(char *) "rect", NULL
34372 };
34373
34374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34376 if (!SWIG_IsOK(res1)) {
34377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34378 }
34379 arg1 = reinterpret_cast< wxWindow * >(argp1);
34380 {
34381 arg2 = &temp2;
34382 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34383 }
34384 {
34385 PyThreadState* __tstate = wxPyBeginAllowThreads();
34386 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34387 wxPyEndAllowThreads(__tstate);
34388 if (PyErr_Occurred()) SWIG_fail;
34389 }
34390 {
34391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34392 }
34393 return resultobj;
34394 fail:
34395 return NULL;
34396 }
34397
34398
34399 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34400 PyObject *resultobj = 0;
34401 wxWindow *arg1 = (wxWindow *) 0 ;
34402 SwigValueWrapper<wxVisualAttributes > result;
34403 void *argp1 = 0 ;
34404 int res1 = 0 ;
34405 PyObject *swig_obj[1] ;
34406
34407 if (!args) SWIG_fail;
34408 swig_obj[0] = args;
34409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34410 if (!SWIG_IsOK(res1)) {
34411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34412 }
34413 arg1 = reinterpret_cast< wxWindow * >(argp1);
34414 {
34415 PyThreadState* __tstate = wxPyBeginAllowThreads();
34416 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34417 wxPyEndAllowThreads(__tstate);
34418 if (PyErr_Occurred()) SWIG_fail;
34419 }
34420 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34421 return resultobj;
34422 fail:
34423 return NULL;
34424 }
34425
34426
34427 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34428 PyObject *resultobj = 0;
34429 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34430 SwigValueWrapper<wxVisualAttributes > result;
34431 int val1 ;
34432 int ecode1 = 0 ;
34433 PyObject * obj0 = 0 ;
34434 char * kwnames[] = {
34435 (char *) "variant", NULL
34436 };
34437
34438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34439 if (obj0) {
34440 ecode1 = SWIG_AsVal_int(obj0, &val1);
34441 if (!SWIG_IsOK(ecode1)) {
34442 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34443 }
34444 arg1 = static_cast< wxWindowVariant >(val1);
34445 }
34446 {
34447 if (!wxPyCheckForApp()) SWIG_fail;
34448 PyThreadState* __tstate = wxPyBeginAllowThreads();
34449 result = wxWindow::GetClassDefaultAttributes(arg1);
34450 wxPyEndAllowThreads(__tstate);
34451 if (PyErr_Occurred()) SWIG_fail;
34452 }
34453 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34454 return resultobj;
34455 fail:
34456 return NULL;
34457 }
34458
34459
34460 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34461 PyObject *resultobj = 0;
34462 wxWindow *arg1 = (wxWindow *) 0 ;
34463 wxColour *arg2 = 0 ;
34464 bool result;
34465 void *argp1 = 0 ;
34466 int res1 = 0 ;
34467 wxColour temp2 ;
34468 PyObject * obj0 = 0 ;
34469 PyObject * obj1 = 0 ;
34470 char * kwnames[] = {
34471 (char *) "self",(char *) "colour", NULL
34472 };
34473
34474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34476 if (!SWIG_IsOK(res1)) {
34477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34478 }
34479 arg1 = reinterpret_cast< wxWindow * >(argp1);
34480 {
34481 arg2 = &temp2;
34482 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34483 }
34484 {
34485 PyThreadState* __tstate = wxPyBeginAllowThreads();
34486 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34487 wxPyEndAllowThreads(__tstate);
34488 if (PyErr_Occurred()) SWIG_fail;
34489 }
34490 {
34491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34492 }
34493 return resultobj;
34494 fail:
34495 return NULL;
34496 }
34497
34498
34499 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34500 PyObject *resultobj = 0;
34501 wxWindow *arg1 = (wxWindow *) 0 ;
34502 wxColour *arg2 = 0 ;
34503 void *argp1 = 0 ;
34504 int res1 = 0 ;
34505 wxColour temp2 ;
34506 PyObject * obj0 = 0 ;
34507 PyObject * obj1 = 0 ;
34508 char * kwnames[] = {
34509 (char *) "self",(char *) "colour", NULL
34510 };
34511
34512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34514 if (!SWIG_IsOK(res1)) {
34515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34516 }
34517 arg1 = reinterpret_cast< wxWindow * >(argp1);
34518 {
34519 arg2 = &temp2;
34520 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34521 }
34522 {
34523 PyThreadState* __tstate = wxPyBeginAllowThreads();
34524 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34525 wxPyEndAllowThreads(__tstate);
34526 if (PyErr_Occurred()) SWIG_fail;
34527 }
34528 resultobj = SWIG_Py_Void();
34529 return resultobj;
34530 fail:
34531 return NULL;
34532 }
34533
34534
34535 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34536 PyObject *resultobj = 0;
34537 wxWindow *arg1 = (wxWindow *) 0 ;
34538 wxColour *arg2 = 0 ;
34539 bool result;
34540 void *argp1 = 0 ;
34541 int res1 = 0 ;
34542 wxColour temp2 ;
34543 PyObject * obj0 = 0 ;
34544 PyObject * obj1 = 0 ;
34545 char * kwnames[] = {
34546 (char *) "self",(char *) "colour", NULL
34547 };
34548
34549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34551 if (!SWIG_IsOK(res1)) {
34552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34553 }
34554 arg1 = reinterpret_cast< wxWindow * >(argp1);
34555 {
34556 arg2 = &temp2;
34557 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34558 }
34559 {
34560 PyThreadState* __tstate = wxPyBeginAllowThreads();
34561 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34562 wxPyEndAllowThreads(__tstate);
34563 if (PyErr_Occurred()) SWIG_fail;
34564 }
34565 {
34566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34567 }
34568 return resultobj;
34569 fail:
34570 return NULL;
34571 }
34572
34573
34574 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34575 PyObject *resultobj = 0;
34576 wxWindow *arg1 = (wxWindow *) 0 ;
34577 wxColour *arg2 = 0 ;
34578 void *argp1 = 0 ;
34579 int res1 = 0 ;
34580 wxColour temp2 ;
34581 PyObject * obj0 = 0 ;
34582 PyObject * obj1 = 0 ;
34583 char * kwnames[] = {
34584 (char *) "self",(char *) "colour", NULL
34585 };
34586
34587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34589 if (!SWIG_IsOK(res1)) {
34590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34591 }
34592 arg1 = reinterpret_cast< wxWindow * >(argp1);
34593 {
34594 arg2 = &temp2;
34595 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34596 }
34597 {
34598 PyThreadState* __tstate = wxPyBeginAllowThreads();
34599 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34600 wxPyEndAllowThreads(__tstate);
34601 if (PyErr_Occurred()) SWIG_fail;
34602 }
34603 resultobj = SWIG_Py_Void();
34604 return resultobj;
34605 fail:
34606 return NULL;
34607 }
34608
34609
34610 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34611 PyObject *resultobj = 0;
34612 wxWindow *arg1 = (wxWindow *) 0 ;
34613 wxColour result;
34614 void *argp1 = 0 ;
34615 int res1 = 0 ;
34616 PyObject *swig_obj[1] ;
34617
34618 if (!args) SWIG_fail;
34619 swig_obj[0] = args;
34620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34621 if (!SWIG_IsOK(res1)) {
34622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34623 }
34624 arg1 = reinterpret_cast< wxWindow * >(argp1);
34625 {
34626 PyThreadState* __tstate = wxPyBeginAllowThreads();
34627 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34628 wxPyEndAllowThreads(__tstate);
34629 if (PyErr_Occurred()) SWIG_fail;
34630 }
34631 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34632 return resultobj;
34633 fail:
34634 return NULL;
34635 }
34636
34637
34638 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34639 PyObject *resultobj = 0;
34640 wxWindow *arg1 = (wxWindow *) 0 ;
34641 wxColour result;
34642 void *argp1 = 0 ;
34643 int res1 = 0 ;
34644 PyObject *swig_obj[1] ;
34645
34646 if (!args) SWIG_fail;
34647 swig_obj[0] = args;
34648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34649 if (!SWIG_IsOK(res1)) {
34650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34651 }
34652 arg1 = reinterpret_cast< wxWindow * >(argp1);
34653 {
34654 PyThreadState* __tstate = wxPyBeginAllowThreads();
34655 result = ((wxWindow const *)arg1)->GetForegroundColour();
34656 wxPyEndAllowThreads(__tstate);
34657 if (PyErr_Occurred()) SWIG_fail;
34658 }
34659 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34660 return resultobj;
34661 fail:
34662 return NULL;
34663 }
34664
34665
34666 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34667 PyObject *resultobj = 0;
34668 wxWindow *arg1 = (wxWindow *) 0 ;
34669 bool result;
34670 void *argp1 = 0 ;
34671 int res1 = 0 ;
34672 PyObject *swig_obj[1] ;
34673
34674 if (!args) SWIG_fail;
34675 swig_obj[0] = args;
34676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34677 if (!SWIG_IsOK(res1)) {
34678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34679 }
34680 arg1 = reinterpret_cast< wxWindow * >(argp1);
34681 {
34682 PyThreadState* __tstate = wxPyBeginAllowThreads();
34683 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34684 wxPyEndAllowThreads(__tstate);
34685 if (PyErr_Occurred()) SWIG_fail;
34686 }
34687 {
34688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34689 }
34690 return resultobj;
34691 fail:
34692 return NULL;
34693 }
34694
34695
34696 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34697 PyObject *resultobj = 0;
34698 wxWindow *arg1 = (wxWindow *) 0 ;
34699 bool result;
34700 void *argp1 = 0 ;
34701 int res1 = 0 ;
34702 PyObject *swig_obj[1] ;
34703
34704 if (!args) SWIG_fail;
34705 swig_obj[0] = args;
34706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34707 if (!SWIG_IsOK(res1)) {
34708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34709 }
34710 arg1 = reinterpret_cast< wxWindow * >(argp1);
34711 {
34712 PyThreadState* __tstate = wxPyBeginAllowThreads();
34713 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34714 wxPyEndAllowThreads(__tstate);
34715 if (PyErr_Occurred()) SWIG_fail;
34716 }
34717 {
34718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34719 }
34720 return resultobj;
34721 fail:
34722 return NULL;
34723 }
34724
34725
34726 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34727 PyObject *resultobj = 0;
34728 wxWindow *arg1 = (wxWindow *) 0 ;
34729 wxBackgroundStyle arg2 ;
34730 bool result;
34731 void *argp1 = 0 ;
34732 int res1 = 0 ;
34733 int val2 ;
34734 int ecode2 = 0 ;
34735 PyObject * obj0 = 0 ;
34736 PyObject * obj1 = 0 ;
34737 char * kwnames[] = {
34738 (char *) "self",(char *) "style", NULL
34739 };
34740
34741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34743 if (!SWIG_IsOK(res1)) {
34744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34745 }
34746 arg1 = reinterpret_cast< wxWindow * >(argp1);
34747 ecode2 = SWIG_AsVal_int(obj1, &val2);
34748 if (!SWIG_IsOK(ecode2)) {
34749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34750 }
34751 arg2 = static_cast< wxBackgroundStyle >(val2);
34752 {
34753 PyThreadState* __tstate = wxPyBeginAllowThreads();
34754 result = (bool)(arg1)->SetBackgroundStyle(arg2);
34755 wxPyEndAllowThreads(__tstate);
34756 if (PyErr_Occurred()) SWIG_fail;
34757 }
34758 {
34759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34760 }
34761 return resultobj;
34762 fail:
34763 return NULL;
34764 }
34765
34766
34767 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34768 PyObject *resultobj = 0;
34769 wxWindow *arg1 = (wxWindow *) 0 ;
34770 wxBackgroundStyle result;
34771 void *argp1 = 0 ;
34772 int res1 = 0 ;
34773 PyObject *swig_obj[1] ;
34774
34775 if (!args) SWIG_fail;
34776 swig_obj[0] = args;
34777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34778 if (!SWIG_IsOK(res1)) {
34779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34780 }
34781 arg1 = reinterpret_cast< wxWindow * >(argp1);
34782 {
34783 PyThreadState* __tstate = wxPyBeginAllowThreads();
34784 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34785 wxPyEndAllowThreads(__tstate);
34786 if (PyErr_Occurred()) SWIG_fail;
34787 }
34788 resultobj = SWIG_From_int(static_cast< int >(result));
34789 return resultobj;
34790 fail:
34791 return NULL;
34792 }
34793
34794
34795 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34796 PyObject *resultobj = 0;
34797 wxWindow *arg1 = (wxWindow *) 0 ;
34798 bool result;
34799 void *argp1 = 0 ;
34800 int res1 = 0 ;
34801 PyObject *swig_obj[1] ;
34802
34803 if (!args) SWIG_fail;
34804 swig_obj[0] = args;
34805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34806 if (!SWIG_IsOK(res1)) {
34807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34808 }
34809 arg1 = reinterpret_cast< wxWindow * >(argp1);
34810 {
34811 PyThreadState* __tstate = wxPyBeginAllowThreads();
34812 result = (bool)(arg1)->HasTransparentBackground();
34813 wxPyEndAllowThreads(__tstate);
34814 if (PyErr_Occurred()) SWIG_fail;
34815 }
34816 {
34817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34818 }
34819 return resultobj;
34820 fail:
34821 return NULL;
34822 }
34823
34824
34825 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34826 PyObject *resultobj = 0;
34827 wxWindow *arg1 = (wxWindow *) 0 ;
34828 wxCursor *arg2 = 0 ;
34829 bool result;
34830 void *argp1 = 0 ;
34831 int res1 = 0 ;
34832 void *argp2 = 0 ;
34833 int res2 = 0 ;
34834 PyObject * obj0 = 0 ;
34835 PyObject * obj1 = 0 ;
34836 char * kwnames[] = {
34837 (char *) "self",(char *) "cursor", NULL
34838 };
34839
34840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
34841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34842 if (!SWIG_IsOK(res1)) {
34843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
34844 }
34845 arg1 = reinterpret_cast< wxWindow * >(argp1);
34846 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
34847 if (!SWIG_IsOK(res2)) {
34848 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34849 }
34850 if (!argp2) {
34851 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34852 }
34853 arg2 = reinterpret_cast< wxCursor * >(argp2);
34854 {
34855 PyThreadState* __tstate = wxPyBeginAllowThreads();
34856 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
34857 wxPyEndAllowThreads(__tstate);
34858 if (PyErr_Occurred()) SWIG_fail;
34859 }
34860 {
34861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34862 }
34863 return resultobj;
34864 fail:
34865 return NULL;
34866 }
34867
34868
34869 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34870 PyObject *resultobj = 0;
34871 wxWindow *arg1 = (wxWindow *) 0 ;
34872 wxCursor result;
34873 void *argp1 = 0 ;
34874 int res1 = 0 ;
34875 PyObject *swig_obj[1] ;
34876
34877 if (!args) SWIG_fail;
34878 swig_obj[0] = args;
34879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34880 if (!SWIG_IsOK(res1)) {
34881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
34882 }
34883 arg1 = reinterpret_cast< wxWindow * >(argp1);
34884 {
34885 PyThreadState* __tstate = wxPyBeginAllowThreads();
34886 result = (arg1)->GetCursor();
34887 wxPyEndAllowThreads(__tstate);
34888 if (PyErr_Occurred()) SWIG_fail;
34889 }
34890 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
34891 return resultobj;
34892 fail:
34893 return NULL;
34894 }
34895
34896
34897 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34898 PyObject *resultobj = 0;
34899 wxWindow *arg1 = (wxWindow *) 0 ;
34900 wxFont *arg2 = 0 ;
34901 bool result;
34902 void *argp1 = 0 ;
34903 int res1 = 0 ;
34904 void *argp2 = 0 ;
34905 int res2 = 0 ;
34906 PyObject * obj0 = 0 ;
34907 PyObject * obj1 = 0 ;
34908 char * kwnames[] = {
34909 (char *) "self",(char *) "font", NULL
34910 };
34911
34912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
34913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34914 if (!SWIG_IsOK(res1)) {
34915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
34916 }
34917 arg1 = reinterpret_cast< wxWindow * >(argp1);
34918 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
34919 if (!SWIG_IsOK(res2)) {
34920 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
34921 }
34922 if (!argp2) {
34923 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
34924 }
34925 arg2 = reinterpret_cast< wxFont * >(argp2);
34926 {
34927 PyThreadState* __tstate = wxPyBeginAllowThreads();
34928 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
34929 wxPyEndAllowThreads(__tstate);
34930 if (PyErr_Occurred()) SWIG_fail;
34931 }
34932 {
34933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34934 }
34935 return resultobj;
34936 fail:
34937 return NULL;
34938 }
34939
34940
34941 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34942 PyObject *resultobj = 0;
34943 wxWindow *arg1 = (wxWindow *) 0 ;
34944 wxFont *arg2 = 0 ;
34945 void *argp1 = 0 ;
34946 int res1 = 0 ;
34947 void *argp2 = 0 ;
34948 int res2 = 0 ;
34949 PyObject * obj0 = 0 ;
34950 PyObject * obj1 = 0 ;
34951 char * kwnames[] = {
34952 (char *) "self",(char *) "font", NULL
34953 };
34954
34955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
34956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34957 if (!SWIG_IsOK(res1)) {
34958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
34959 }
34960 arg1 = reinterpret_cast< wxWindow * >(argp1);
34961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
34962 if (!SWIG_IsOK(res2)) {
34963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
34964 }
34965 if (!argp2) {
34966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
34967 }
34968 arg2 = reinterpret_cast< wxFont * >(argp2);
34969 {
34970 PyThreadState* __tstate = wxPyBeginAllowThreads();
34971 (arg1)->SetOwnFont((wxFont const &)*arg2);
34972 wxPyEndAllowThreads(__tstate);
34973 if (PyErr_Occurred()) SWIG_fail;
34974 }
34975 resultobj = SWIG_Py_Void();
34976 return resultobj;
34977 fail:
34978 return NULL;
34979 }
34980
34981
34982 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34983 PyObject *resultobj = 0;
34984 wxWindow *arg1 = (wxWindow *) 0 ;
34985 wxFont result;
34986 void *argp1 = 0 ;
34987 int res1 = 0 ;
34988 PyObject *swig_obj[1] ;
34989
34990 if (!args) SWIG_fail;
34991 swig_obj[0] = args;
34992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34993 if (!SWIG_IsOK(res1)) {
34994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
34995 }
34996 arg1 = reinterpret_cast< wxWindow * >(argp1);
34997 {
34998 PyThreadState* __tstate = wxPyBeginAllowThreads();
34999 result = (arg1)->GetFont();
35000 wxPyEndAllowThreads(__tstate);
35001 if (PyErr_Occurred()) SWIG_fail;
35002 }
35003 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35004 return resultobj;
35005 fail:
35006 return NULL;
35007 }
35008
35009
35010 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35011 PyObject *resultobj = 0;
35012 wxWindow *arg1 = (wxWindow *) 0 ;
35013 wxCaret *arg2 = (wxCaret *) 0 ;
35014 void *argp1 = 0 ;
35015 int res1 = 0 ;
35016 int res2 = 0 ;
35017 PyObject * obj0 = 0 ;
35018 PyObject * obj1 = 0 ;
35019 char * kwnames[] = {
35020 (char *) "self",(char *) "caret", NULL
35021 };
35022
35023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35025 if (!SWIG_IsOK(res1)) {
35026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35027 }
35028 arg1 = reinterpret_cast< wxWindow * >(argp1);
35029 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35030 if (!SWIG_IsOK(res2)) {
35031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35032 }
35033 {
35034 PyThreadState* __tstate = wxPyBeginAllowThreads();
35035 (arg1)->SetCaret(arg2);
35036 wxPyEndAllowThreads(__tstate);
35037 if (PyErr_Occurred()) SWIG_fail;
35038 }
35039 resultobj = SWIG_Py_Void();
35040 return resultobj;
35041 fail:
35042 return NULL;
35043 }
35044
35045
35046 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35047 PyObject *resultobj = 0;
35048 wxWindow *arg1 = (wxWindow *) 0 ;
35049 wxCaret *result = 0 ;
35050 void *argp1 = 0 ;
35051 int res1 = 0 ;
35052 PyObject *swig_obj[1] ;
35053
35054 if (!args) SWIG_fail;
35055 swig_obj[0] = args;
35056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35057 if (!SWIG_IsOK(res1)) {
35058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35059 }
35060 arg1 = reinterpret_cast< wxWindow * >(argp1);
35061 {
35062 PyThreadState* __tstate = wxPyBeginAllowThreads();
35063 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35064 wxPyEndAllowThreads(__tstate);
35065 if (PyErr_Occurred()) SWIG_fail;
35066 }
35067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35068 return resultobj;
35069 fail:
35070 return NULL;
35071 }
35072
35073
35074 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35075 PyObject *resultobj = 0;
35076 wxWindow *arg1 = (wxWindow *) 0 ;
35077 int result;
35078 void *argp1 = 0 ;
35079 int res1 = 0 ;
35080 PyObject *swig_obj[1] ;
35081
35082 if (!args) SWIG_fail;
35083 swig_obj[0] = args;
35084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35085 if (!SWIG_IsOK(res1)) {
35086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35087 }
35088 arg1 = reinterpret_cast< wxWindow * >(argp1);
35089 {
35090 PyThreadState* __tstate = wxPyBeginAllowThreads();
35091 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35092 wxPyEndAllowThreads(__tstate);
35093 if (PyErr_Occurred()) SWIG_fail;
35094 }
35095 resultobj = SWIG_From_int(static_cast< int >(result));
35096 return resultobj;
35097 fail:
35098 return NULL;
35099 }
35100
35101
35102 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35103 PyObject *resultobj = 0;
35104 wxWindow *arg1 = (wxWindow *) 0 ;
35105 int result;
35106 void *argp1 = 0 ;
35107 int res1 = 0 ;
35108 PyObject *swig_obj[1] ;
35109
35110 if (!args) SWIG_fail;
35111 swig_obj[0] = args;
35112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35113 if (!SWIG_IsOK(res1)) {
35114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35115 }
35116 arg1 = reinterpret_cast< wxWindow * >(argp1);
35117 {
35118 PyThreadState* __tstate = wxPyBeginAllowThreads();
35119 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35120 wxPyEndAllowThreads(__tstate);
35121 if (PyErr_Occurred()) SWIG_fail;
35122 }
35123 resultobj = SWIG_From_int(static_cast< int >(result));
35124 return resultobj;
35125 fail:
35126 return NULL;
35127 }
35128
35129
35130 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35131 PyObject *resultobj = 0;
35132 wxWindow *arg1 = (wxWindow *) 0 ;
35133 wxString *arg2 = 0 ;
35134 int *arg3 = (int *) 0 ;
35135 int *arg4 = (int *) 0 ;
35136 void *argp1 = 0 ;
35137 int res1 = 0 ;
35138 bool temp2 = false ;
35139 int temp3 ;
35140 int res3 = SWIG_TMPOBJ ;
35141 int temp4 ;
35142 int res4 = SWIG_TMPOBJ ;
35143 PyObject * obj0 = 0 ;
35144 PyObject * obj1 = 0 ;
35145 char * kwnames[] = {
35146 (char *) "self",(char *) "string", NULL
35147 };
35148
35149 arg3 = &temp3;
35150 arg4 = &temp4;
35151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35153 if (!SWIG_IsOK(res1)) {
35154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35155 }
35156 arg1 = reinterpret_cast< wxWindow * >(argp1);
35157 {
35158 arg2 = wxString_in_helper(obj1);
35159 if (arg2 == NULL) SWIG_fail;
35160 temp2 = true;
35161 }
35162 {
35163 PyThreadState* __tstate = wxPyBeginAllowThreads();
35164 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35165 wxPyEndAllowThreads(__tstate);
35166 if (PyErr_Occurred()) SWIG_fail;
35167 }
35168 resultobj = SWIG_Py_Void();
35169 if (SWIG_IsTmpObj(res3)) {
35170 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35171 } else {
35172 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35174 }
35175 if (SWIG_IsTmpObj(res4)) {
35176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35177 } else {
35178 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35180 }
35181 {
35182 if (temp2)
35183 delete arg2;
35184 }
35185 return resultobj;
35186 fail:
35187 {
35188 if (temp2)
35189 delete arg2;
35190 }
35191 return NULL;
35192 }
35193
35194
35195 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35196 PyObject *resultobj = 0;
35197 wxWindow *arg1 = (wxWindow *) 0 ;
35198 wxString *arg2 = 0 ;
35199 int *arg3 = (int *) 0 ;
35200 int *arg4 = (int *) 0 ;
35201 int *arg5 = (int *) 0 ;
35202 int *arg6 = (int *) 0 ;
35203 wxFont *arg7 = (wxFont *) NULL ;
35204 void *argp1 = 0 ;
35205 int res1 = 0 ;
35206 bool temp2 = false ;
35207 int temp3 ;
35208 int res3 = SWIG_TMPOBJ ;
35209 int temp4 ;
35210 int res4 = SWIG_TMPOBJ ;
35211 int temp5 ;
35212 int res5 = SWIG_TMPOBJ ;
35213 int temp6 ;
35214 int res6 = SWIG_TMPOBJ ;
35215 void *argp7 = 0 ;
35216 int res7 = 0 ;
35217 PyObject * obj0 = 0 ;
35218 PyObject * obj1 = 0 ;
35219 PyObject * obj2 = 0 ;
35220 char * kwnames[] = {
35221 (char *) "self",(char *) "string",(char *) "font", NULL
35222 };
35223
35224 arg3 = &temp3;
35225 arg4 = &temp4;
35226 arg5 = &temp5;
35227 arg6 = &temp6;
35228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35230 if (!SWIG_IsOK(res1)) {
35231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35232 }
35233 arg1 = reinterpret_cast< wxWindow * >(argp1);
35234 {
35235 arg2 = wxString_in_helper(obj1);
35236 if (arg2 == NULL) SWIG_fail;
35237 temp2 = true;
35238 }
35239 if (obj2) {
35240 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35241 if (!SWIG_IsOK(res7)) {
35242 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35243 }
35244 arg7 = reinterpret_cast< wxFont * >(argp7);
35245 }
35246 {
35247 PyThreadState* __tstate = wxPyBeginAllowThreads();
35248 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35249 wxPyEndAllowThreads(__tstate);
35250 if (PyErr_Occurred()) SWIG_fail;
35251 }
35252 resultobj = SWIG_Py_Void();
35253 if (SWIG_IsTmpObj(res3)) {
35254 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35255 } else {
35256 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35257 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35258 }
35259 if (SWIG_IsTmpObj(res4)) {
35260 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35261 } else {
35262 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35263 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35264 }
35265 if (SWIG_IsTmpObj(res5)) {
35266 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35267 } else {
35268 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35269 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35270 }
35271 if (SWIG_IsTmpObj(res6)) {
35272 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35273 } else {
35274 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35275 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35276 }
35277 {
35278 if (temp2)
35279 delete arg2;
35280 }
35281 return resultobj;
35282 fail:
35283 {
35284 if (temp2)
35285 delete arg2;
35286 }
35287 return NULL;
35288 }
35289
35290
35291 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35292 PyObject *resultobj = 0;
35293 wxWindow *arg1 = (wxWindow *) 0 ;
35294 int *arg2 = (int *) 0 ;
35295 int *arg3 = (int *) 0 ;
35296 void *argp1 = 0 ;
35297 int res1 = 0 ;
35298 int temp2 ;
35299 int res2 = 0 ;
35300 int temp3 ;
35301 int res3 = 0 ;
35302 PyObject * obj0 = 0 ;
35303 PyObject * obj1 = 0 ;
35304 PyObject * obj2 = 0 ;
35305 char * kwnames[] = {
35306 (char *) "self",(char *) "x",(char *) "y", NULL
35307 };
35308
35309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35311 if (!SWIG_IsOK(res1)) {
35312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35313 }
35314 arg1 = reinterpret_cast< wxWindow * >(argp1);
35315 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35316 int val;
35317 int ecode = SWIG_AsVal_int(obj1, &val);
35318 if (!SWIG_IsOK(ecode)) {
35319 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35320 }
35321 temp2 = static_cast< int >(val);
35322 arg2 = &temp2;
35323 res2 = SWIG_AddTmpMask(ecode);
35324 }
35325 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35326 int val;
35327 int ecode = SWIG_AsVal_int(obj2, &val);
35328 if (!SWIG_IsOK(ecode)) {
35329 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35330 }
35331 temp3 = static_cast< int >(val);
35332 arg3 = &temp3;
35333 res3 = SWIG_AddTmpMask(ecode);
35334 }
35335 {
35336 PyThreadState* __tstate = wxPyBeginAllowThreads();
35337 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35338 wxPyEndAllowThreads(__tstate);
35339 if (PyErr_Occurred()) SWIG_fail;
35340 }
35341 resultobj = SWIG_Py_Void();
35342 if (SWIG_IsTmpObj(res2)) {
35343 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35344 } else {
35345 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35346 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35347 }
35348 if (SWIG_IsTmpObj(res3)) {
35349 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35350 } else {
35351 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35352 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35353 }
35354 return resultobj;
35355 fail:
35356 return NULL;
35357 }
35358
35359
35360 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35361 PyObject *resultobj = 0;
35362 wxWindow *arg1 = (wxWindow *) 0 ;
35363 int *arg2 = (int *) 0 ;
35364 int *arg3 = (int *) 0 ;
35365 void *argp1 = 0 ;
35366 int res1 = 0 ;
35367 int temp2 ;
35368 int res2 = 0 ;
35369 int temp3 ;
35370 int res3 = 0 ;
35371 PyObject * obj0 = 0 ;
35372 PyObject * obj1 = 0 ;
35373 PyObject * obj2 = 0 ;
35374 char * kwnames[] = {
35375 (char *) "self",(char *) "x",(char *) "y", NULL
35376 };
35377
35378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35380 if (!SWIG_IsOK(res1)) {
35381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35382 }
35383 arg1 = reinterpret_cast< wxWindow * >(argp1);
35384 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35385 int val;
35386 int ecode = SWIG_AsVal_int(obj1, &val);
35387 if (!SWIG_IsOK(ecode)) {
35388 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35389 }
35390 temp2 = static_cast< int >(val);
35391 arg2 = &temp2;
35392 res2 = SWIG_AddTmpMask(ecode);
35393 }
35394 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35395 int val;
35396 int ecode = SWIG_AsVal_int(obj2, &val);
35397 if (!SWIG_IsOK(ecode)) {
35398 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35399 }
35400 temp3 = static_cast< int >(val);
35401 arg3 = &temp3;
35402 res3 = SWIG_AddTmpMask(ecode);
35403 }
35404 {
35405 PyThreadState* __tstate = wxPyBeginAllowThreads();
35406 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35407 wxPyEndAllowThreads(__tstate);
35408 if (PyErr_Occurred()) SWIG_fail;
35409 }
35410 resultobj = SWIG_Py_Void();
35411 if (SWIG_IsTmpObj(res2)) {
35412 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35413 } else {
35414 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35415 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35416 }
35417 if (SWIG_IsTmpObj(res3)) {
35418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35419 } else {
35420 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35422 }
35423 return resultobj;
35424 fail:
35425 return NULL;
35426 }
35427
35428
35429 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35430 PyObject *resultobj = 0;
35431 wxWindow *arg1 = (wxWindow *) 0 ;
35432 wxPoint *arg2 = 0 ;
35433 wxPoint result;
35434 void *argp1 = 0 ;
35435 int res1 = 0 ;
35436 wxPoint temp2 ;
35437 PyObject * obj0 = 0 ;
35438 PyObject * obj1 = 0 ;
35439 char * kwnames[] = {
35440 (char *) "self",(char *) "pt", NULL
35441 };
35442
35443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35445 if (!SWIG_IsOK(res1)) {
35446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35447 }
35448 arg1 = reinterpret_cast< wxWindow * >(argp1);
35449 {
35450 arg2 = &temp2;
35451 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35452 }
35453 {
35454 PyThreadState* __tstate = wxPyBeginAllowThreads();
35455 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35456 wxPyEndAllowThreads(__tstate);
35457 if (PyErr_Occurred()) SWIG_fail;
35458 }
35459 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35460 return resultobj;
35461 fail:
35462 return NULL;
35463 }
35464
35465
35466 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35467 PyObject *resultobj = 0;
35468 wxWindow *arg1 = (wxWindow *) 0 ;
35469 wxPoint *arg2 = 0 ;
35470 wxPoint result;
35471 void *argp1 = 0 ;
35472 int res1 = 0 ;
35473 wxPoint temp2 ;
35474 PyObject * obj0 = 0 ;
35475 PyObject * obj1 = 0 ;
35476 char * kwnames[] = {
35477 (char *) "self",(char *) "pt", NULL
35478 };
35479
35480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35482 if (!SWIG_IsOK(res1)) {
35483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35484 }
35485 arg1 = reinterpret_cast< wxWindow * >(argp1);
35486 {
35487 arg2 = &temp2;
35488 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35489 }
35490 {
35491 PyThreadState* __tstate = wxPyBeginAllowThreads();
35492 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35493 wxPyEndAllowThreads(__tstate);
35494 if (PyErr_Occurred()) SWIG_fail;
35495 }
35496 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35497 return resultobj;
35498 fail:
35499 return NULL;
35500 }
35501
35502
35503 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35504 PyObject *resultobj = 0;
35505 wxWindow *arg1 = (wxWindow *) 0 ;
35506 int arg2 ;
35507 int arg3 ;
35508 wxHitTest result;
35509 void *argp1 = 0 ;
35510 int res1 = 0 ;
35511 int val2 ;
35512 int ecode2 = 0 ;
35513 int val3 ;
35514 int ecode3 = 0 ;
35515 PyObject * obj0 = 0 ;
35516 PyObject * obj1 = 0 ;
35517 PyObject * obj2 = 0 ;
35518 char * kwnames[] = {
35519 (char *) "self",(char *) "x",(char *) "y", NULL
35520 };
35521
35522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35524 if (!SWIG_IsOK(res1)) {
35525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35526 }
35527 arg1 = reinterpret_cast< wxWindow * >(argp1);
35528 ecode2 = SWIG_AsVal_int(obj1, &val2);
35529 if (!SWIG_IsOK(ecode2)) {
35530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35531 }
35532 arg2 = static_cast< int >(val2);
35533 ecode3 = SWIG_AsVal_int(obj2, &val3);
35534 if (!SWIG_IsOK(ecode3)) {
35535 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35536 }
35537 arg3 = static_cast< int >(val3);
35538 {
35539 PyThreadState* __tstate = wxPyBeginAllowThreads();
35540 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35541 wxPyEndAllowThreads(__tstate);
35542 if (PyErr_Occurred()) SWIG_fail;
35543 }
35544 resultobj = SWIG_From_int(static_cast< int >(result));
35545 return resultobj;
35546 fail:
35547 return NULL;
35548 }
35549
35550
35551 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35552 PyObject *resultobj = 0;
35553 wxWindow *arg1 = (wxWindow *) 0 ;
35554 wxPoint *arg2 = 0 ;
35555 wxHitTest result;
35556 void *argp1 = 0 ;
35557 int res1 = 0 ;
35558 wxPoint temp2 ;
35559 PyObject * obj0 = 0 ;
35560 PyObject * obj1 = 0 ;
35561 char * kwnames[] = {
35562 (char *) "self",(char *) "pt", NULL
35563 };
35564
35565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35567 if (!SWIG_IsOK(res1)) {
35568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35569 }
35570 arg1 = reinterpret_cast< wxWindow * >(argp1);
35571 {
35572 arg2 = &temp2;
35573 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35574 }
35575 {
35576 PyThreadState* __tstate = wxPyBeginAllowThreads();
35577 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35578 wxPyEndAllowThreads(__tstate);
35579 if (PyErr_Occurred()) SWIG_fail;
35580 }
35581 resultobj = SWIG_From_int(static_cast< int >(result));
35582 return resultobj;
35583 fail:
35584 return NULL;
35585 }
35586
35587
35588 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35589 PyObject *resultobj = 0;
35590 wxWindow *arg1 = (wxWindow *) 0 ;
35591 long arg2 ;
35592 wxBorder result;
35593 void *argp1 = 0 ;
35594 int res1 = 0 ;
35595 long val2 ;
35596 int ecode2 = 0 ;
35597
35598 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35600 if (!SWIG_IsOK(res1)) {
35601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35602 }
35603 arg1 = reinterpret_cast< wxWindow * >(argp1);
35604 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35605 if (!SWIG_IsOK(ecode2)) {
35606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35607 }
35608 arg2 = static_cast< long >(val2);
35609 {
35610 PyThreadState* __tstate = wxPyBeginAllowThreads();
35611 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35612 wxPyEndAllowThreads(__tstate);
35613 if (PyErr_Occurred()) SWIG_fail;
35614 }
35615 resultobj = SWIG_From_int(static_cast< int >(result));
35616 return resultobj;
35617 fail:
35618 return NULL;
35619 }
35620
35621
35622 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35623 PyObject *resultobj = 0;
35624 wxWindow *arg1 = (wxWindow *) 0 ;
35625 wxBorder result;
35626 void *argp1 = 0 ;
35627 int res1 = 0 ;
35628
35629 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35631 if (!SWIG_IsOK(res1)) {
35632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35633 }
35634 arg1 = reinterpret_cast< wxWindow * >(argp1);
35635 {
35636 PyThreadState* __tstate = wxPyBeginAllowThreads();
35637 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35638 wxPyEndAllowThreads(__tstate);
35639 if (PyErr_Occurred()) SWIG_fail;
35640 }
35641 resultobj = SWIG_From_int(static_cast< int >(result));
35642 return resultobj;
35643 fail:
35644 return NULL;
35645 }
35646
35647
35648 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35649 int argc;
35650 PyObject *argv[3];
35651
35652 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35653 --argc;
35654 if (argc == 1) {
35655 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35656 }
35657 if (argc == 2) {
35658 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35659 }
35660
35661 fail:
35662 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35663 return NULL;
35664 }
35665
35666
35667 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35668 PyObject *resultobj = 0;
35669 wxWindow *arg1 = (wxWindow *) 0 ;
35670 long arg2 = (long) wxUPDATE_UI_NONE ;
35671 void *argp1 = 0 ;
35672 int res1 = 0 ;
35673 long val2 ;
35674 int ecode2 = 0 ;
35675 PyObject * obj0 = 0 ;
35676 PyObject * obj1 = 0 ;
35677 char * kwnames[] = {
35678 (char *) "self",(char *) "flags", NULL
35679 };
35680
35681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35683 if (!SWIG_IsOK(res1)) {
35684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35685 }
35686 arg1 = reinterpret_cast< wxWindow * >(argp1);
35687 if (obj1) {
35688 ecode2 = SWIG_AsVal_long(obj1, &val2);
35689 if (!SWIG_IsOK(ecode2)) {
35690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35691 }
35692 arg2 = static_cast< long >(val2);
35693 }
35694 {
35695 PyThreadState* __tstate = wxPyBeginAllowThreads();
35696 (arg1)->UpdateWindowUI(arg2);
35697 wxPyEndAllowThreads(__tstate);
35698 if (PyErr_Occurred()) SWIG_fail;
35699 }
35700 resultobj = SWIG_Py_Void();
35701 return resultobj;
35702 fail:
35703 return NULL;
35704 }
35705
35706
35707 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35708 PyObject *resultobj = 0;
35709 wxWindow *arg1 = (wxWindow *) 0 ;
35710 wxMenu *arg2 = (wxMenu *) 0 ;
35711 int arg3 = (int) -1 ;
35712 int arg4 = (int) -1 ;
35713 bool result;
35714 void *argp1 = 0 ;
35715 int res1 = 0 ;
35716 void *argp2 = 0 ;
35717 int res2 = 0 ;
35718 int val3 ;
35719 int ecode3 = 0 ;
35720 int val4 ;
35721 int ecode4 = 0 ;
35722 PyObject * obj0 = 0 ;
35723 PyObject * obj1 = 0 ;
35724 PyObject * obj2 = 0 ;
35725 PyObject * obj3 = 0 ;
35726 char * kwnames[] = {
35727 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35728 };
35729
35730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35732 if (!SWIG_IsOK(res1)) {
35733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35734 }
35735 arg1 = reinterpret_cast< wxWindow * >(argp1);
35736 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35737 if (!SWIG_IsOK(res2)) {
35738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35739 }
35740 arg2 = reinterpret_cast< wxMenu * >(argp2);
35741 if (obj2) {
35742 ecode3 = SWIG_AsVal_int(obj2, &val3);
35743 if (!SWIG_IsOK(ecode3)) {
35744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35745 }
35746 arg3 = static_cast< int >(val3);
35747 }
35748 if (obj3) {
35749 ecode4 = SWIG_AsVal_int(obj3, &val4);
35750 if (!SWIG_IsOK(ecode4)) {
35751 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35752 }
35753 arg4 = static_cast< int >(val4);
35754 }
35755 {
35756 PyThreadState* __tstate = wxPyBeginAllowThreads();
35757 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35758 wxPyEndAllowThreads(__tstate);
35759 if (PyErr_Occurred()) SWIG_fail;
35760 }
35761 {
35762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35763 }
35764 return resultobj;
35765 fail:
35766 return NULL;
35767 }
35768
35769
35770 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35771 PyObject *resultobj = 0;
35772 wxWindow *arg1 = (wxWindow *) 0 ;
35773 wxMenu *arg2 = (wxMenu *) 0 ;
35774 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35775 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35776 bool result;
35777 void *argp1 = 0 ;
35778 int res1 = 0 ;
35779 void *argp2 = 0 ;
35780 int res2 = 0 ;
35781 wxPoint temp3 ;
35782 PyObject * obj0 = 0 ;
35783 PyObject * obj1 = 0 ;
35784 PyObject * obj2 = 0 ;
35785 char * kwnames[] = {
35786 (char *) "self",(char *) "menu",(char *) "pos", NULL
35787 };
35788
35789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35791 if (!SWIG_IsOK(res1)) {
35792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
35793 }
35794 arg1 = reinterpret_cast< wxWindow * >(argp1);
35795 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35796 if (!SWIG_IsOK(res2)) {
35797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
35798 }
35799 arg2 = reinterpret_cast< wxMenu * >(argp2);
35800 if (obj2) {
35801 {
35802 arg3 = &temp3;
35803 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
35804 }
35805 }
35806 {
35807 PyThreadState* __tstate = wxPyBeginAllowThreads();
35808 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
35809 wxPyEndAllowThreads(__tstate);
35810 if (PyErr_Occurred()) SWIG_fail;
35811 }
35812 {
35813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35814 }
35815 return resultobj;
35816 fail:
35817 return NULL;
35818 }
35819
35820
35821 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35822 PyObject *resultobj = 0;
35823 wxWindow *arg1 = (wxWindow *) 0 ;
35824 long result;
35825 void *argp1 = 0 ;
35826 int res1 = 0 ;
35827 PyObject *swig_obj[1] ;
35828
35829 if (!args) SWIG_fail;
35830 swig_obj[0] = args;
35831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35832 if (!SWIG_IsOK(res1)) {
35833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35834 }
35835 arg1 = reinterpret_cast< wxWindow * >(argp1);
35836 {
35837 PyThreadState* __tstate = wxPyBeginAllowThreads();
35838 result = (long)wxWindow_GetHandle(arg1);
35839 wxPyEndAllowThreads(__tstate);
35840 if (PyErr_Occurred()) SWIG_fail;
35841 }
35842 resultobj = SWIG_From_long(static_cast< long >(result));
35843 return resultobj;
35844 fail:
35845 return NULL;
35846 }
35847
35848
35849 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35850 PyObject *resultobj = 0;
35851 wxWindow *arg1 = (wxWindow *) 0 ;
35852 long arg2 ;
35853 void *argp1 = 0 ;
35854 int res1 = 0 ;
35855 long val2 ;
35856 int ecode2 = 0 ;
35857 PyObject * obj0 = 0 ;
35858 PyObject * obj1 = 0 ;
35859 char * kwnames[] = {
35860 (char *) "self",(char *) "handle", NULL
35861 };
35862
35863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
35864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35865 if (!SWIG_IsOK(res1)) {
35866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35867 }
35868 arg1 = reinterpret_cast< wxWindow * >(argp1);
35869 ecode2 = SWIG_AsVal_long(obj1, &val2);
35870 if (!SWIG_IsOK(ecode2)) {
35871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
35872 }
35873 arg2 = static_cast< long >(val2);
35874 {
35875 PyThreadState* __tstate = wxPyBeginAllowThreads();
35876 wxWindow_AssociateHandle(arg1,arg2);
35877 wxPyEndAllowThreads(__tstate);
35878 if (PyErr_Occurred()) SWIG_fail;
35879 }
35880 resultobj = SWIG_Py_Void();
35881 return resultobj;
35882 fail:
35883 return NULL;
35884 }
35885
35886
35887 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35888 PyObject *resultobj = 0;
35889 wxWindow *arg1 = (wxWindow *) 0 ;
35890 void *argp1 = 0 ;
35891 int res1 = 0 ;
35892 PyObject *swig_obj[1] ;
35893
35894 if (!args) SWIG_fail;
35895 swig_obj[0] = args;
35896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35897 if (!SWIG_IsOK(res1)) {
35898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35899 }
35900 arg1 = reinterpret_cast< wxWindow * >(argp1);
35901 {
35902 PyThreadState* __tstate = wxPyBeginAllowThreads();
35903 (arg1)->DissociateHandle();
35904 wxPyEndAllowThreads(__tstate);
35905 if (PyErr_Occurred()) SWIG_fail;
35906 }
35907 resultobj = SWIG_Py_Void();
35908 return resultobj;
35909 fail:
35910 return NULL;
35911 }
35912
35913
35914 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35915 PyObject *resultobj = 0;
35916 wxWindow *arg1 = (wxWindow *) 0 ;
35917 wxPaintEvent *arg2 = 0 ;
35918 void *argp1 = 0 ;
35919 int res1 = 0 ;
35920 void *argp2 = 0 ;
35921 int res2 = 0 ;
35922 PyObject * obj0 = 0 ;
35923 PyObject * obj1 = 0 ;
35924 char * kwnames[] = {
35925 (char *) "self",(char *) "event", NULL
35926 };
35927
35928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
35929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35930 if (!SWIG_IsOK(res1)) {
35931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
35932 }
35933 arg1 = reinterpret_cast< wxWindow * >(argp1);
35934 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
35935 if (!SWIG_IsOK(res2)) {
35936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
35937 }
35938 if (!argp2) {
35939 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
35940 }
35941 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
35942 {
35943 PyThreadState* __tstate = wxPyBeginAllowThreads();
35944 (arg1)->OnPaint(*arg2);
35945 wxPyEndAllowThreads(__tstate);
35946 if (PyErr_Occurred()) SWIG_fail;
35947 }
35948 resultobj = SWIG_Py_Void();
35949 return resultobj;
35950 fail:
35951 return NULL;
35952 }
35953
35954
35955 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35956 PyObject *resultobj = 0;
35957 wxWindow *arg1 = (wxWindow *) 0 ;
35958 int arg2 ;
35959 bool result;
35960 void *argp1 = 0 ;
35961 int res1 = 0 ;
35962 int val2 ;
35963 int ecode2 = 0 ;
35964 PyObject * obj0 = 0 ;
35965 PyObject * obj1 = 0 ;
35966 char * kwnames[] = {
35967 (char *) "self",(char *) "orient", NULL
35968 };
35969
35970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
35971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35972 if (!SWIG_IsOK(res1)) {
35973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
35974 }
35975 arg1 = reinterpret_cast< wxWindow * >(argp1);
35976 ecode2 = SWIG_AsVal_int(obj1, &val2);
35977 if (!SWIG_IsOK(ecode2)) {
35978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
35979 }
35980 arg2 = static_cast< int >(val2);
35981 {
35982 PyThreadState* __tstate = wxPyBeginAllowThreads();
35983 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
35984 wxPyEndAllowThreads(__tstate);
35985 if (PyErr_Occurred()) SWIG_fail;
35986 }
35987 {
35988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35989 }
35990 return resultobj;
35991 fail:
35992 return NULL;
35993 }
35994
35995
35996 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35997 PyObject *resultobj = 0;
35998 wxWindow *arg1 = (wxWindow *) 0 ;
35999 int arg2 ;
36000 int arg3 ;
36001 int arg4 ;
36002 int arg5 ;
36003 bool arg6 = (bool) true ;
36004 void *argp1 = 0 ;
36005 int res1 = 0 ;
36006 int val2 ;
36007 int ecode2 = 0 ;
36008 int val3 ;
36009 int ecode3 = 0 ;
36010 int val4 ;
36011 int ecode4 = 0 ;
36012 int val5 ;
36013 int ecode5 = 0 ;
36014 bool val6 ;
36015 int ecode6 = 0 ;
36016 PyObject * obj0 = 0 ;
36017 PyObject * obj1 = 0 ;
36018 PyObject * obj2 = 0 ;
36019 PyObject * obj3 = 0 ;
36020 PyObject * obj4 = 0 ;
36021 PyObject * obj5 = 0 ;
36022 char * kwnames[] = {
36023 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36024 };
36025
36026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36028 if (!SWIG_IsOK(res1)) {
36029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36030 }
36031 arg1 = reinterpret_cast< wxWindow * >(argp1);
36032 ecode2 = SWIG_AsVal_int(obj1, &val2);
36033 if (!SWIG_IsOK(ecode2)) {
36034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36035 }
36036 arg2 = static_cast< int >(val2);
36037 ecode3 = SWIG_AsVal_int(obj2, &val3);
36038 if (!SWIG_IsOK(ecode3)) {
36039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36040 }
36041 arg3 = static_cast< int >(val3);
36042 ecode4 = SWIG_AsVal_int(obj3, &val4);
36043 if (!SWIG_IsOK(ecode4)) {
36044 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36045 }
36046 arg4 = static_cast< int >(val4);
36047 ecode5 = SWIG_AsVal_int(obj4, &val5);
36048 if (!SWIG_IsOK(ecode5)) {
36049 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36050 }
36051 arg5 = static_cast< int >(val5);
36052 if (obj5) {
36053 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36054 if (!SWIG_IsOK(ecode6)) {
36055 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36056 }
36057 arg6 = static_cast< bool >(val6);
36058 }
36059 {
36060 PyThreadState* __tstate = wxPyBeginAllowThreads();
36061 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36062 wxPyEndAllowThreads(__tstate);
36063 if (PyErr_Occurred()) SWIG_fail;
36064 }
36065 resultobj = SWIG_Py_Void();
36066 return resultobj;
36067 fail:
36068 return NULL;
36069 }
36070
36071
36072 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36073 PyObject *resultobj = 0;
36074 wxWindow *arg1 = (wxWindow *) 0 ;
36075 int arg2 ;
36076 int arg3 ;
36077 bool arg4 = (bool) true ;
36078 void *argp1 = 0 ;
36079 int res1 = 0 ;
36080 int val2 ;
36081 int ecode2 = 0 ;
36082 int val3 ;
36083 int ecode3 = 0 ;
36084 bool val4 ;
36085 int ecode4 = 0 ;
36086 PyObject * obj0 = 0 ;
36087 PyObject * obj1 = 0 ;
36088 PyObject * obj2 = 0 ;
36089 PyObject * obj3 = 0 ;
36090 char * kwnames[] = {
36091 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36092 };
36093
36094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36096 if (!SWIG_IsOK(res1)) {
36097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36098 }
36099 arg1 = reinterpret_cast< wxWindow * >(argp1);
36100 ecode2 = SWIG_AsVal_int(obj1, &val2);
36101 if (!SWIG_IsOK(ecode2)) {
36102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36103 }
36104 arg2 = static_cast< int >(val2);
36105 ecode3 = SWIG_AsVal_int(obj2, &val3);
36106 if (!SWIG_IsOK(ecode3)) {
36107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36108 }
36109 arg3 = static_cast< int >(val3);
36110 if (obj3) {
36111 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36112 if (!SWIG_IsOK(ecode4)) {
36113 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36114 }
36115 arg4 = static_cast< bool >(val4);
36116 }
36117 {
36118 PyThreadState* __tstate = wxPyBeginAllowThreads();
36119 (arg1)->SetScrollPos(arg2,arg3,arg4);
36120 wxPyEndAllowThreads(__tstate);
36121 if (PyErr_Occurred()) SWIG_fail;
36122 }
36123 resultobj = SWIG_Py_Void();
36124 return resultobj;
36125 fail:
36126 return NULL;
36127 }
36128
36129
36130 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36131 PyObject *resultobj = 0;
36132 wxWindow *arg1 = (wxWindow *) 0 ;
36133 int arg2 ;
36134 int result;
36135 void *argp1 = 0 ;
36136 int res1 = 0 ;
36137 int val2 ;
36138 int ecode2 = 0 ;
36139 PyObject * obj0 = 0 ;
36140 PyObject * obj1 = 0 ;
36141 char * kwnames[] = {
36142 (char *) "self",(char *) "orientation", NULL
36143 };
36144
36145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36147 if (!SWIG_IsOK(res1)) {
36148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36149 }
36150 arg1 = reinterpret_cast< wxWindow * >(argp1);
36151 ecode2 = SWIG_AsVal_int(obj1, &val2);
36152 if (!SWIG_IsOK(ecode2)) {
36153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36154 }
36155 arg2 = static_cast< int >(val2);
36156 {
36157 PyThreadState* __tstate = wxPyBeginAllowThreads();
36158 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36159 wxPyEndAllowThreads(__tstate);
36160 if (PyErr_Occurred()) SWIG_fail;
36161 }
36162 resultobj = SWIG_From_int(static_cast< int >(result));
36163 return resultobj;
36164 fail:
36165 return NULL;
36166 }
36167
36168
36169 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36170 PyObject *resultobj = 0;
36171 wxWindow *arg1 = (wxWindow *) 0 ;
36172 int arg2 ;
36173 int result;
36174 void *argp1 = 0 ;
36175 int res1 = 0 ;
36176 int val2 ;
36177 int ecode2 = 0 ;
36178 PyObject * obj0 = 0 ;
36179 PyObject * obj1 = 0 ;
36180 char * kwnames[] = {
36181 (char *) "self",(char *) "orientation", NULL
36182 };
36183
36184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36186 if (!SWIG_IsOK(res1)) {
36187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36188 }
36189 arg1 = reinterpret_cast< wxWindow * >(argp1);
36190 ecode2 = SWIG_AsVal_int(obj1, &val2);
36191 if (!SWIG_IsOK(ecode2)) {
36192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36193 }
36194 arg2 = static_cast< int >(val2);
36195 {
36196 PyThreadState* __tstate = wxPyBeginAllowThreads();
36197 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36198 wxPyEndAllowThreads(__tstate);
36199 if (PyErr_Occurred()) SWIG_fail;
36200 }
36201 resultobj = SWIG_From_int(static_cast< int >(result));
36202 return resultobj;
36203 fail:
36204 return NULL;
36205 }
36206
36207
36208 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36209 PyObject *resultobj = 0;
36210 wxWindow *arg1 = (wxWindow *) 0 ;
36211 int arg2 ;
36212 int result;
36213 void *argp1 = 0 ;
36214 int res1 = 0 ;
36215 int val2 ;
36216 int ecode2 = 0 ;
36217 PyObject * obj0 = 0 ;
36218 PyObject * obj1 = 0 ;
36219 char * kwnames[] = {
36220 (char *) "self",(char *) "orientation", NULL
36221 };
36222
36223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36225 if (!SWIG_IsOK(res1)) {
36226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36227 }
36228 arg1 = reinterpret_cast< wxWindow * >(argp1);
36229 ecode2 = SWIG_AsVal_int(obj1, &val2);
36230 if (!SWIG_IsOK(ecode2)) {
36231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36232 }
36233 arg2 = static_cast< int >(val2);
36234 {
36235 PyThreadState* __tstate = wxPyBeginAllowThreads();
36236 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36237 wxPyEndAllowThreads(__tstate);
36238 if (PyErr_Occurred()) SWIG_fail;
36239 }
36240 resultobj = SWIG_From_int(static_cast< int >(result));
36241 return resultobj;
36242 fail:
36243 return NULL;
36244 }
36245
36246
36247 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36248 PyObject *resultobj = 0;
36249 wxWindow *arg1 = (wxWindow *) 0 ;
36250 int arg2 ;
36251 int arg3 ;
36252 wxRect *arg4 = (wxRect *) NULL ;
36253 void *argp1 = 0 ;
36254 int res1 = 0 ;
36255 int val2 ;
36256 int ecode2 = 0 ;
36257 int val3 ;
36258 int ecode3 = 0 ;
36259 void *argp4 = 0 ;
36260 int res4 = 0 ;
36261 PyObject * obj0 = 0 ;
36262 PyObject * obj1 = 0 ;
36263 PyObject * obj2 = 0 ;
36264 PyObject * obj3 = 0 ;
36265 char * kwnames[] = {
36266 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36267 };
36268
36269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36271 if (!SWIG_IsOK(res1)) {
36272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36273 }
36274 arg1 = reinterpret_cast< wxWindow * >(argp1);
36275 ecode2 = SWIG_AsVal_int(obj1, &val2);
36276 if (!SWIG_IsOK(ecode2)) {
36277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36278 }
36279 arg2 = static_cast< int >(val2);
36280 ecode3 = SWIG_AsVal_int(obj2, &val3);
36281 if (!SWIG_IsOK(ecode3)) {
36282 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36283 }
36284 arg3 = static_cast< int >(val3);
36285 if (obj3) {
36286 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36287 if (!SWIG_IsOK(res4)) {
36288 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36289 }
36290 arg4 = reinterpret_cast< wxRect * >(argp4);
36291 }
36292 {
36293 PyThreadState* __tstate = wxPyBeginAllowThreads();
36294 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36295 wxPyEndAllowThreads(__tstate);
36296 if (PyErr_Occurred()) SWIG_fail;
36297 }
36298 resultobj = SWIG_Py_Void();
36299 return resultobj;
36300 fail:
36301 return NULL;
36302 }
36303
36304
36305 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36306 PyObject *resultobj = 0;
36307 wxWindow *arg1 = (wxWindow *) 0 ;
36308 int arg2 ;
36309 bool result;
36310 void *argp1 = 0 ;
36311 int res1 = 0 ;
36312 int val2 ;
36313 int ecode2 = 0 ;
36314 PyObject * obj0 = 0 ;
36315 PyObject * obj1 = 0 ;
36316 char * kwnames[] = {
36317 (char *) "self",(char *) "lines", NULL
36318 };
36319
36320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36322 if (!SWIG_IsOK(res1)) {
36323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36324 }
36325 arg1 = reinterpret_cast< wxWindow * >(argp1);
36326 ecode2 = SWIG_AsVal_int(obj1, &val2);
36327 if (!SWIG_IsOK(ecode2)) {
36328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36329 }
36330 arg2 = static_cast< int >(val2);
36331 {
36332 PyThreadState* __tstate = wxPyBeginAllowThreads();
36333 result = (bool)(arg1)->ScrollLines(arg2);
36334 wxPyEndAllowThreads(__tstate);
36335 if (PyErr_Occurred()) SWIG_fail;
36336 }
36337 {
36338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36339 }
36340 return resultobj;
36341 fail:
36342 return NULL;
36343 }
36344
36345
36346 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36347 PyObject *resultobj = 0;
36348 wxWindow *arg1 = (wxWindow *) 0 ;
36349 int arg2 ;
36350 bool result;
36351 void *argp1 = 0 ;
36352 int res1 = 0 ;
36353 int val2 ;
36354 int ecode2 = 0 ;
36355 PyObject * obj0 = 0 ;
36356 PyObject * obj1 = 0 ;
36357 char * kwnames[] = {
36358 (char *) "self",(char *) "pages", NULL
36359 };
36360
36361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36363 if (!SWIG_IsOK(res1)) {
36364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36365 }
36366 arg1 = reinterpret_cast< wxWindow * >(argp1);
36367 ecode2 = SWIG_AsVal_int(obj1, &val2);
36368 if (!SWIG_IsOK(ecode2)) {
36369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36370 }
36371 arg2 = static_cast< int >(val2);
36372 {
36373 PyThreadState* __tstate = wxPyBeginAllowThreads();
36374 result = (bool)(arg1)->ScrollPages(arg2);
36375 wxPyEndAllowThreads(__tstate);
36376 if (PyErr_Occurred()) SWIG_fail;
36377 }
36378 {
36379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36380 }
36381 return resultobj;
36382 fail:
36383 return NULL;
36384 }
36385
36386
36387 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36388 PyObject *resultobj = 0;
36389 wxWindow *arg1 = (wxWindow *) 0 ;
36390 bool result;
36391 void *argp1 = 0 ;
36392 int res1 = 0 ;
36393 PyObject *swig_obj[1] ;
36394
36395 if (!args) SWIG_fail;
36396 swig_obj[0] = args;
36397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36398 if (!SWIG_IsOK(res1)) {
36399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36400 }
36401 arg1 = reinterpret_cast< wxWindow * >(argp1);
36402 {
36403 PyThreadState* __tstate = wxPyBeginAllowThreads();
36404 result = (bool)(arg1)->LineUp();
36405 wxPyEndAllowThreads(__tstate);
36406 if (PyErr_Occurred()) SWIG_fail;
36407 }
36408 {
36409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36410 }
36411 return resultobj;
36412 fail:
36413 return NULL;
36414 }
36415
36416
36417 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36418 PyObject *resultobj = 0;
36419 wxWindow *arg1 = (wxWindow *) 0 ;
36420 bool result;
36421 void *argp1 = 0 ;
36422 int res1 = 0 ;
36423 PyObject *swig_obj[1] ;
36424
36425 if (!args) SWIG_fail;
36426 swig_obj[0] = args;
36427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36428 if (!SWIG_IsOK(res1)) {
36429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36430 }
36431 arg1 = reinterpret_cast< wxWindow * >(argp1);
36432 {
36433 PyThreadState* __tstate = wxPyBeginAllowThreads();
36434 result = (bool)(arg1)->LineDown();
36435 wxPyEndAllowThreads(__tstate);
36436 if (PyErr_Occurred()) SWIG_fail;
36437 }
36438 {
36439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36440 }
36441 return resultobj;
36442 fail:
36443 return NULL;
36444 }
36445
36446
36447 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36448 PyObject *resultobj = 0;
36449 wxWindow *arg1 = (wxWindow *) 0 ;
36450 bool result;
36451 void *argp1 = 0 ;
36452 int res1 = 0 ;
36453 PyObject *swig_obj[1] ;
36454
36455 if (!args) SWIG_fail;
36456 swig_obj[0] = args;
36457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36458 if (!SWIG_IsOK(res1)) {
36459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36460 }
36461 arg1 = reinterpret_cast< wxWindow * >(argp1);
36462 {
36463 PyThreadState* __tstate = wxPyBeginAllowThreads();
36464 result = (bool)(arg1)->PageUp();
36465 wxPyEndAllowThreads(__tstate);
36466 if (PyErr_Occurred()) SWIG_fail;
36467 }
36468 {
36469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36470 }
36471 return resultobj;
36472 fail:
36473 return NULL;
36474 }
36475
36476
36477 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36478 PyObject *resultobj = 0;
36479 wxWindow *arg1 = (wxWindow *) 0 ;
36480 bool result;
36481 void *argp1 = 0 ;
36482 int res1 = 0 ;
36483 PyObject *swig_obj[1] ;
36484
36485 if (!args) SWIG_fail;
36486 swig_obj[0] = args;
36487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36488 if (!SWIG_IsOK(res1)) {
36489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36490 }
36491 arg1 = reinterpret_cast< wxWindow * >(argp1);
36492 {
36493 PyThreadState* __tstate = wxPyBeginAllowThreads();
36494 result = (bool)(arg1)->PageDown();
36495 wxPyEndAllowThreads(__tstate);
36496 if (PyErr_Occurred()) SWIG_fail;
36497 }
36498 {
36499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36500 }
36501 return resultobj;
36502 fail:
36503 return NULL;
36504 }
36505
36506
36507 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36508 PyObject *resultobj = 0;
36509 wxWindow *arg1 = (wxWindow *) 0 ;
36510 wxString *arg2 = 0 ;
36511 void *argp1 = 0 ;
36512 int res1 = 0 ;
36513 bool temp2 = false ;
36514 PyObject * obj0 = 0 ;
36515 PyObject * obj1 = 0 ;
36516 char * kwnames[] = {
36517 (char *) "self",(char *) "text", NULL
36518 };
36519
36520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36522 if (!SWIG_IsOK(res1)) {
36523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36524 }
36525 arg1 = reinterpret_cast< wxWindow * >(argp1);
36526 {
36527 arg2 = wxString_in_helper(obj1);
36528 if (arg2 == NULL) SWIG_fail;
36529 temp2 = true;
36530 }
36531 {
36532 PyThreadState* __tstate = wxPyBeginAllowThreads();
36533 (arg1)->SetHelpText((wxString const &)*arg2);
36534 wxPyEndAllowThreads(__tstate);
36535 if (PyErr_Occurred()) SWIG_fail;
36536 }
36537 resultobj = SWIG_Py_Void();
36538 {
36539 if (temp2)
36540 delete arg2;
36541 }
36542 return resultobj;
36543 fail:
36544 {
36545 if (temp2)
36546 delete arg2;
36547 }
36548 return NULL;
36549 }
36550
36551
36552 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36553 PyObject *resultobj = 0;
36554 wxWindow *arg1 = (wxWindow *) 0 ;
36555 wxString *arg2 = 0 ;
36556 void *argp1 = 0 ;
36557 int res1 = 0 ;
36558 bool temp2 = false ;
36559 PyObject * obj0 = 0 ;
36560 PyObject * obj1 = 0 ;
36561 char * kwnames[] = {
36562 (char *) "self",(char *) "text", NULL
36563 };
36564
36565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36567 if (!SWIG_IsOK(res1)) {
36568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36569 }
36570 arg1 = reinterpret_cast< wxWindow * >(argp1);
36571 {
36572 arg2 = wxString_in_helper(obj1);
36573 if (arg2 == NULL) SWIG_fail;
36574 temp2 = true;
36575 }
36576 {
36577 PyThreadState* __tstate = wxPyBeginAllowThreads();
36578 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36579 wxPyEndAllowThreads(__tstate);
36580 if (PyErr_Occurred()) SWIG_fail;
36581 }
36582 resultobj = SWIG_Py_Void();
36583 {
36584 if (temp2)
36585 delete arg2;
36586 }
36587 return resultobj;
36588 fail:
36589 {
36590 if (temp2)
36591 delete arg2;
36592 }
36593 return NULL;
36594 }
36595
36596
36597 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36598 PyObject *resultobj = 0;
36599 wxWindow *arg1 = (wxWindow *) 0 ;
36600 wxString result;
36601 void *argp1 = 0 ;
36602 int res1 = 0 ;
36603 PyObject *swig_obj[1] ;
36604
36605 if (!args) SWIG_fail;
36606 swig_obj[0] = args;
36607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36608 if (!SWIG_IsOK(res1)) {
36609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36610 }
36611 arg1 = reinterpret_cast< wxWindow * >(argp1);
36612 {
36613 PyThreadState* __tstate = wxPyBeginAllowThreads();
36614 result = ((wxWindow const *)arg1)->GetHelpText();
36615 wxPyEndAllowThreads(__tstate);
36616 if (PyErr_Occurred()) SWIG_fail;
36617 }
36618 {
36619 #if wxUSE_UNICODE
36620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36621 #else
36622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36623 #endif
36624 }
36625 return resultobj;
36626 fail:
36627 return NULL;
36628 }
36629
36630
36631 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36632 PyObject *resultobj = 0;
36633 wxWindow *arg1 = (wxWindow *) 0 ;
36634 wxString *arg2 = 0 ;
36635 void *argp1 = 0 ;
36636 int res1 = 0 ;
36637 bool temp2 = false ;
36638 PyObject * obj0 = 0 ;
36639 PyObject * obj1 = 0 ;
36640 char * kwnames[] = {
36641 (char *) "self",(char *) "tip", NULL
36642 };
36643
36644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36646 if (!SWIG_IsOK(res1)) {
36647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36648 }
36649 arg1 = reinterpret_cast< wxWindow * >(argp1);
36650 {
36651 arg2 = wxString_in_helper(obj1);
36652 if (arg2 == NULL) SWIG_fail;
36653 temp2 = true;
36654 }
36655 {
36656 PyThreadState* __tstate = wxPyBeginAllowThreads();
36657 (arg1)->SetToolTip((wxString const &)*arg2);
36658 wxPyEndAllowThreads(__tstate);
36659 if (PyErr_Occurred()) SWIG_fail;
36660 }
36661 resultobj = SWIG_Py_Void();
36662 {
36663 if (temp2)
36664 delete arg2;
36665 }
36666 return resultobj;
36667 fail:
36668 {
36669 if (temp2)
36670 delete arg2;
36671 }
36672 return NULL;
36673 }
36674
36675
36676 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36677 PyObject *resultobj = 0;
36678 wxWindow *arg1 = (wxWindow *) 0 ;
36679 wxToolTip *arg2 = (wxToolTip *) 0 ;
36680 void *argp1 = 0 ;
36681 int res1 = 0 ;
36682 int res2 = 0 ;
36683 PyObject * obj0 = 0 ;
36684 PyObject * obj1 = 0 ;
36685 char * kwnames[] = {
36686 (char *) "self",(char *) "tip", NULL
36687 };
36688
36689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36691 if (!SWIG_IsOK(res1)) {
36692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36693 }
36694 arg1 = reinterpret_cast< wxWindow * >(argp1);
36695 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36696 if (!SWIG_IsOK(res2)) {
36697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36698 }
36699 {
36700 PyThreadState* __tstate = wxPyBeginAllowThreads();
36701 (arg1)->SetToolTip(arg2);
36702 wxPyEndAllowThreads(__tstate);
36703 if (PyErr_Occurred()) SWIG_fail;
36704 }
36705 resultobj = SWIG_Py_Void();
36706 return resultobj;
36707 fail:
36708 return NULL;
36709 }
36710
36711
36712 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36713 PyObject *resultobj = 0;
36714 wxWindow *arg1 = (wxWindow *) 0 ;
36715 wxToolTip *result = 0 ;
36716 void *argp1 = 0 ;
36717 int res1 = 0 ;
36718 PyObject *swig_obj[1] ;
36719
36720 if (!args) SWIG_fail;
36721 swig_obj[0] = args;
36722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36723 if (!SWIG_IsOK(res1)) {
36724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36725 }
36726 arg1 = reinterpret_cast< wxWindow * >(argp1);
36727 {
36728 PyThreadState* __tstate = wxPyBeginAllowThreads();
36729 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36730 wxPyEndAllowThreads(__tstate);
36731 if (PyErr_Occurred()) SWIG_fail;
36732 }
36733 {
36734 resultobj = wxPyMake_wxObject(result, (bool)0);
36735 }
36736 return resultobj;
36737 fail:
36738 return NULL;
36739 }
36740
36741
36742 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36743 PyObject *resultobj = 0;
36744 wxWindow *arg1 = (wxWindow *) 0 ;
36745 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36746 void *argp1 = 0 ;
36747 int res1 = 0 ;
36748 int res2 = 0 ;
36749 PyObject * obj0 = 0 ;
36750 PyObject * obj1 = 0 ;
36751 char * kwnames[] = {
36752 (char *) "self",(char *) "dropTarget", NULL
36753 };
36754
36755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36757 if (!SWIG_IsOK(res1)) {
36758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36759 }
36760 arg1 = reinterpret_cast< wxWindow * >(argp1);
36761 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36762 if (!SWIG_IsOK(res2)) {
36763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36764 }
36765 {
36766 PyThreadState* __tstate = wxPyBeginAllowThreads();
36767 (arg1)->SetDropTarget(arg2);
36768 wxPyEndAllowThreads(__tstate);
36769 if (PyErr_Occurred()) SWIG_fail;
36770 }
36771 resultobj = SWIG_Py_Void();
36772 return resultobj;
36773 fail:
36774 return NULL;
36775 }
36776
36777
36778 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36779 PyObject *resultobj = 0;
36780 wxWindow *arg1 = (wxWindow *) 0 ;
36781 wxPyDropTarget *result = 0 ;
36782 void *argp1 = 0 ;
36783 int res1 = 0 ;
36784 PyObject *swig_obj[1] ;
36785
36786 if (!args) SWIG_fail;
36787 swig_obj[0] = args;
36788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36789 if (!SWIG_IsOK(res1)) {
36790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36791 }
36792 arg1 = reinterpret_cast< wxWindow * >(argp1);
36793 {
36794 PyThreadState* __tstate = wxPyBeginAllowThreads();
36795 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36796 wxPyEndAllowThreads(__tstate);
36797 if (PyErr_Occurred()) SWIG_fail;
36798 }
36799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36800 return resultobj;
36801 fail:
36802 return NULL;
36803 }
36804
36805
36806 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36807 PyObject *resultobj = 0;
36808 wxWindow *arg1 = (wxWindow *) 0 ;
36809 bool arg2 ;
36810 void *argp1 = 0 ;
36811 int res1 = 0 ;
36812 bool val2 ;
36813 int ecode2 = 0 ;
36814 PyObject * obj0 = 0 ;
36815 PyObject * obj1 = 0 ;
36816 char * kwnames[] = {
36817 (char *) "self",(char *) "accept", NULL
36818 };
36819
36820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
36821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36822 if (!SWIG_IsOK(res1)) {
36823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
36824 }
36825 arg1 = reinterpret_cast< wxWindow * >(argp1);
36826 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36827 if (!SWIG_IsOK(ecode2)) {
36828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
36829 }
36830 arg2 = static_cast< bool >(val2);
36831 {
36832 PyThreadState* __tstate = wxPyBeginAllowThreads();
36833 (arg1)->DragAcceptFiles(arg2);
36834 wxPyEndAllowThreads(__tstate);
36835 if (PyErr_Occurred()) SWIG_fail;
36836 }
36837 resultobj = SWIG_Py_Void();
36838 return resultobj;
36839 fail:
36840 return NULL;
36841 }
36842
36843
36844 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36845 PyObject *resultobj = 0;
36846 wxWindow *arg1 = (wxWindow *) 0 ;
36847 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
36848 void *argp1 = 0 ;
36849 int res1 = 0 ;
36850 int res2 = 0 ;
36851 PyObject * obj0 = 0 ;
36852 PyObject * obj1 = 0 ;
36853 char * kwnames[] = {
36854 (char *) "self",(char *) "constraints", NULL
36855 };
36856
36857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
36858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36859 if (!SWIG_IsOK(res1)) {
36860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
36861 }
36862 arg1 = reinterpret_cast< wxWindow * >(argp1);
36863 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
36864 if (!SWIG_IsOK(res2)) {
36865 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
36866 }
36867 {
36868 PyThreadState* __tstate = wxPyBeginAllowThreads();
36869 (arg1)->SetConstraints(arg2);
36870 wxPyEndAllowThreads(__tstate);
36871 if (PyErr_Occurred()) SWIG_fail;
36872 }
36873 resultobj = SWIG_Py_Void();
36874 return resultobj;
36875 fail:
36876 return NULL;
36877 }
36878
36879
36880 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36881 PyObject *resultobj = 0;
36882 wxWindow *arg1 = (wxWindow *) 0 ;
36883 wxLayoutConstraints *result = 0 ;
36884 void *argp1 = 0 ;
36885 int res1 = 0 ;
36886 PyObject *swig_obj[1] ;
36887
36888 if (!args) SWIG_fail;
36889 swig_obj[0] = args;
36890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36891 if (!SWIG_IsOK(res1)) {
36892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
36893 }
36894 arg1 = reinterpret_cast< wxWindow * >(argp1);
36895 {
36896 PyThreadState* __tstate = wxPyBeginAllowThreads();
36897 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
36898 wxPyEndAllowThreads(__tstate);
36899 if (PyErr_Occurred()) SWIG_fail;
36900 }
36901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
36902 return resultobj;
36903 fail:
36904 return NULL;
36905 }
36906
36907
36908 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36909 PyObject *resultobj = 0;
36910 wxWindow *arg1 = (wxWindow *) 0 ;
36911 bool arg2 ;
36912 void *argp1 = 0 ;
36913 int res1 = 0 ;
36914 bool val2 ;
36915 int ecode2 = 0 ;
36916 PyObject * obj0 = 0 ;
36917 PyObject * obj1 = 0 ;
36918 char * kwnames[] = {
36919 (char *) "self",(char *) "autoLayout", NULL
36920 };
36921
36922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
36923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36924 if (!SWIG_IsOK(res1)) {
36925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
36926 }
36927 arg1 = reinterpret_cast< wxWindow * >(argp1);
36928 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36929 if (!SWIG_IsOK(ecode2)) {
36930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
36931 }
36932 arg2 = static_cast< bool >(val2);
36933 {
36934 PyThreadState* __tstate = wxPyBeginAllowThreads();
36935 (arg1)->SetAutoLayout(arg2);
36936 wxPyEndAllowThreads(__tstate);
36937 if (PyErr_Occurred()) SWIG_fail;
36938 }
36939 resultobj = SWIG_Py_Void();
36940 return resultobj;
36941 fail:
36942 return NULL;
36943 }
36944
36945
36946 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36947 PyObject *resultobj = 0;
36948 wxWindow *arg1 = (wxWindow *) 0 ;
36949 bool result;
36950 void *argp1 = 0 ;
36951 int res1 = 0 ;
36952 PyObject *swig_obj[1] ;
36953
36954 if (!args) SWIG_fail;
36955 swig_obj[0] = args;
36956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36957 if (!SWIG_IsOK(res1)) {
36958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
36959 }
36960 arg1 = reinterpret_cast< wxWindow * >(argp1);
36961 {
36962 PyThreadState* __tstate = wxPyBeginAllowThreads();
36963 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
36964 wxPyEndAllowThreads(__tstate);
36965 if (PyErr_Occurred()) SWIG_fail;
36966 }
36967 {
36968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36969 }
36970 return resultobj;
36971 fail:
36972 return NULL;
36973 }
36974
36975
36976 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36977 PyObject *resultobj = 0;
36978 wxWindow *arg1 = (wxWindow *) 0 ;
36979 bool result;
36980 void *argp1 = 0 ;
36981 int res1 = 0 ;
36982 PyObject *swig_obj[1] ;
36983
36984 if (!args) SWIG_fail;
36985 swig_obj[0] = args;
36986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36987 if (!SWIG_IsOK(res1)) {
36988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
36989 }
36990 arg1 = reinterpret_cast< wxWindow * >(argp1);
36991 {
36992 PyThreadState* __tstate = wxPyBeginAllowThreads();
36993 result = (bool)(arg1)->Layout();
36994 wxPyEndAllowThreads(__tstate);
36995 if (PyErr_Occurred()) SWIG_fail;
36996 }
36997 {
36998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36999 }
37000 return resultobj;
37001 fail:
37002 return NULL;
37003 }
37004
37005
37006 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37007 PyObject *resultobj = 0;
37008 wxWindow *arg1 = (wxWindow *) 0 ;
37009 wxSizer *arg2 = (wxSizer *) 0 ;
37010 bool arg3 = (bool) true ;
37011 void *argp1 = 0 ;
37012 int res1 = 0 ;
37013 int res2 = 0 ;
37014 bool val3 ;
37015 int ecode3 = 0 ;
37016 PyObject * obj0 = 0 ;
37017 PyObject * obj1 = 0 ;
37018 PyObject * obj2 = 0 ;
37019 char * kwnames[] = {
37020 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37021 };
37022
37023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37025 if (!SWIG_IsOK(res1)) {
37026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37027 }
37028 arg1 = reinterpret_cast< wxWindow * >(argp1);
37029 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37030 if (!SWIG_IsOK(res2)) {
37031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37032 }
37033 if (obj2) {
37034 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37035 if (!SWIG_IsOK(ecode3)) {
37036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37037 }
37038 arg3 = static_cast< bool >(val3);
37039 }
37040 {
37041 PyThreadState* __tstate = wxPyBeginAllowThreads();
37042 (arg1)->SetSizer(arg2,arg3);
37043 wxPyEndAllowThreads(__tstate);
37044 if (PyErr_Occurred()) SWIG_fail;
37045 }
37046 resultobj = SWIG_Py_Void();
37047 return resultobj;
37048 fail:
37049 return NULL;
37050 }
37051
37052
37053 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37054 PyObject *resultobj = 0;
37055 wxWindow *arg1 = (wxWindow *) 0 ;
37056 wxSizer *arg2 = (wxSizer *) 0 ;
37057 bool arg3 = (bool) true ;
37058 void *argp1 = 0 ;
37059 int res1 = 0 ;
37060 int res2 = 0 ;
37061 bool val3 ;
37062 int ecode3 = 0 ;
37063 PyObject * obj0 = 0 ;
37064 PyObject * obj1 = 0 ;
37065 PyObject * obj2 = 0 ;
37066 char * kwnames[] = {
37067 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37068 };
37069
37070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37072 if (!SWIG_IsOK(res1)) {
37073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37074 }
37075 arg1 = reinterpret_cast< wxWindow * >(argp1);
37076 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37077 if (!SWIG_IsOK(res2)) {
37078 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37079 }
37080 if (obj2) {
37081 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37082 if (!SWIG_IsOK(ecode3)) {
37083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37084 }
37085 arg3 = static_cast< bool >(val3);
37086 }
37087 {
37088 PyThreadState* __tstate = wxPyBeginAllowThreads();
37089 (arg1)->SetSizerAndFit(arg2,arg3);
37090 wxPyEndAllowThreads(__tstate);
37091 if (PyErr_Occurred()) SWIG_fail;
37092 }
37093 resultobj = SWIG_Py_Void();
37094 return resultobj;
37095 fail:
37096 return NULL;
37097 }
37098
37099
37100 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37101 PyObject *resultobj = 0;
37102 wxWindow *arg1 = (wxWindow *) 0 ;
37103 wxSizer *result = 0 ;
37104 void *argp1 = 0 ;
37105 int res1 = 0 ;
37106 PyObject *swig_obj[1] ;
37107
37108 if (!args) SWIG_fail;
37109 swig_obj[0] = args;
37110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37111 if (!SWIG_IsOK(res1)) {
37112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37113 }
37114 arg1 = reinterpret_cast< wxWindow * >(argp1);
37115 {
37116 PyThreadState* __tstate = wxPyBeginAllowThreads();
37117 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37118 wxPyEndAllowThreads(__tstate);
37119 if (PyErr_Occurred()) SWIG_fail;
37120 }
37121 {
37122 resultobj = wxPyMake_wxObject(result, (bool)0);
37123 }
37124 return resultobj;
37125 fail:
37126 return NULL;
37127 }
37128
37129
37130 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37131 PyObject *resultobj = 0;
37132 wxWindow *arg1 = (wxWindow *) 0 ;
37133 wxSizer *arg2 = (wxSizer *) 0 ;
37134 void *argp1 = 0 ;
37135 int res1 = 0 ;
37136 void *argp2 = 0 ;
37137 int res2 = 0 ;
37138 PyObject * obj0 = 0 ;
37139 PyObject * obj1 = 0 ;
37140 char * kwnames[] = {
37141 (char *) "self",(char *) "sizer", NULL
37142 };
37143
37144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37146 if (!SWIG_IsOK(res1)) {
37147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37148 }
37149 arg1 = reinterpret_cast< wxWindow * >(argp1);
37150 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37151 if (!SWIG_IsOK(res2)) {
37152 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37153 }
37154 arg2 = reinterpret_cast< wxSizer * >(argp2);
37155 {
37156 PyThreadState* __tstate = wxPyBeginAllowThreads();
37157 (arg1)->SetContainingSizer(arg2);
37158 wxPyEndAllowThreads(__tstate);
37159 if (PyErr_Occurred()) SWIG_fail;
37160 }
37161 resultobj = SWIG_Py_Void();
37162 return resultobj;
37163 fail:
37164 return NULL;
37165 }
37166
37167
37168 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37169 PyObject *resultobj = 0;
37170 wxWindow *arg1 = (wxWindow *) 0 ;
37171 wxSizer *result = 0 ;
37172 void *argp1 = 0 ;
37173 int res1 = 0 ;
37174 PyObject *swig_obj[1] ;
37175
37176 if (!args) SWIG_fail;
37177 swig_obj[0] = args;
37178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37179 if (!SWIG_IsOK(res1)) {
37180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37181 }
37182 arg1 = reinterpret_cast< wxWindow * >(argp1);
37183 {
37184 PyThreadState* __tstate = wxPyBeginAllowThreads();
37185 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37186 wxPyEndAllowThreads(__tstate);
37187 if (PyErr_Occurred()) SWIG_fail;
37188 }
37189 {
37190 resultobj = wxPyMake_wxObject(result, (bool)0);
37191 }
37192 return resultobj;
37193 fail:
37194 return NULL;
37195 }
37196
37197
37198 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37199 PyObject *resultobj = 0;
37200 wxWindow *arg1 = (wxWindow *) 0 ;
37201 void *argp1 = 0 ;
37202 int res1 = 0 ;
37203 PyObject *swig_obj[1] ;
37204
37205 if (!args) SWIG_fail;
37206 swig_obj[0] = args;
37207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37208 if (!SWIG_IsOK(res1)) {
37209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37210 }
37211 arg1 = reinterpret_cast< wxWindow * >(argp1);
37212 {
37213 PyThreadState* __tstate = wxPyBeginAllowThreads();
37214 (arg1)->InheritAttributes();
37215 wxPyEndAllowThreads(__tstate);
37216 if (PyErr_Occurred()) SWIG_fail;
37217 }
37218 resultobj = SWIG_Py_Void();
37219 return resultobj;
37220 fail:
37221 return NULL;
37222 }
37223
37224
37225 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37226 PyObject *resultobj = 0;
37227 wxWindow *arg1 = (wxWindow *) 0 ;
37228 bool result;
37229 void *argp1 = 0 ;
37230 int res1 = 0 ;
37231 PyObject *swig_obj[1] ;
37232
37233 if (!args) SWIG_fail;
37234 swig_obj[0] = args;
37235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37236 if (!SWIG_IsOK(res1)) {
37237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37238 }
37239 arg1 = reinterpret_cast< wxWindow * >(argp1);
37240 {
37241 PyThreadState* __tstate = wxPyBeginAllowThreads();
37242 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37243 wxPyEndAllowThreads(__tstate);
37244 if (PyErr_Occurred()) SWIG_fail;
37245 }
37246 {
37247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37248 }
37249 return resultobj;
37250 fail:
37251 return NULL;
37252 }
37253
37254
37255 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37256 PyObject *obj;
37257 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37258 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37259 return SWIG_Py_Void();
37260 }
37261
37262 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37263 return SWIG_Python_InitShadowInstance(args);
37264 }
37265
37266 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37267 PyObject *resultobj = 0;
37268 long arg1 ;
37269 wxWindow *arg2 = (wxWindow *) NULL ;
37270 wxWindow *result = 0 ;
37271 long val1 ;
37272 int ecode1 = 0 ;
37273 void *argp2 = 0 ;
37274 int res2 = 0 ;
37275 PyObject * obj0 = 0 ;
37276 PyObject * obj1 = 0 ;
37277 char * kwnames[] = {
37278 (char *) "id",(char *) "parent", NULL
37279 };
37280
37281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37282 ecode1 = SWIG_AsVal_long(obj0, &val1);
37283 if (!SWIG_IsOK(ecode1)) {
37284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37285 }
37286 arg1 = static_cast< long >(val1);
37287 if (obj1) {
37288 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37289 if (!SWIG_IsOK(res2)) {
37290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37291 }
37292 arg2 = reinterpret_cast< wxWindow * >(argp2);
37293 }
37294 {
37295 if (!wxPyCheckForApp()) SWIG_fail;
37296 PyThreadState* __tstate = wxPyBeginAllowThreads();
37297 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37298 wxPyEndAllowThreads(__tstate);
37299 if (PyErr_Occurred()) SWIG_fail;
37300 }
37301 {
37302 resultobj = wxPyMake_wxObject(result, 0);
37303 }
37304 return resultobj;
37305 fail:
37306 return NULL;
37307 }
37308
37309
37310 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37311 PyObject *resultobj = 0;
37312 wxString *arg1 = 0 ;
37313 wxWindow *arg2 = (wxWindow *) NULL ;
37314 wxWindow *result = 0 ;
37315 bool temp1 = false ;
37316 void *argp2 = 0 ;
37317 int res2 = 0 ;
37318 PyObject * obj0 = 0 ;
37319 PyObject * obj1 = 0 ;
37320 char * kwnames[] = {
37321 (char *) "name",(char *) "parent", NULL
37322 };
37323
37324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37325 {
37326 arg1 = wxString_in_helper(obj0);
37327 if (arg1 == NULL) SWIG_fail;
37328 temp1 = true;
37329 }
37330 if (obj1) {
37331 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37332 if (!SWIG_IsOK(res2)) {
37333 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37334 }
37335 arg2 = reinterpret_cast< wxWindow * >(argp2);
37336 }
37337 {
37338 if (!wxPyCheckForApp()) SWIG_fail;
37339 PyThreadState* __tstate = wxPyBeginAllowThreads();
37340 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37341 wxPyEndAllowThreads(__tstate);
37342 if (PyErr_Occurred()) SWIG_fail;
37343 }
37344 {
37345 resultobj = wxPyMake_wxObject(result, 0);
37346 }
37347 {
37348 if (temp1)
37349 delete arg1;
37350 }
37351 return resultobj;
37352 fail:
37353 {
37354 if (temp1)
37355 delete arg1;
37356 }
37357 return NULL;
37358 }
37359
37360
37361 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37362 PyObject *resultobj = 0;
37363 wxString *arg1 = 0 ;
37364 wxWindow *arg2 = (wxWindow *) NULL ;
37365 wxWindow *result = 0 ;
37366 bool temp1 = false ;
37367 void *argp2 = 0 ;
37368 int res2 = 0 ;
37369 PyObject * obj0 = 0 ;
37370 PyObject * obj1 = 0 ;
37371 char * kwnames[] = {
37372 (char *) "label",(char *) "parent", NULL
37373 };
37374
37375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37376 {
37377 arg1 = wxString_in_helper(obj0);
37378 if (arg1 == NULL) SWIG_fail;
37379 temp1 = true;
37380 }
37381 if (obj1) {
37382 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37383 if (!SWIG_IsOK(res2)) {
37384 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37385 }
37386 arg2 = reinterpret_cast< wxWindow * >(argp2);
37387 }
37388 {
37389 if (!wxPyCheckForApp()) SWIG_fail;
37390 PyThreadState* __tstate = wxPyBeginAllowThreads();
37391 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37392 wxPyEndAllowThreads(__tstate);
37393 if (PyErr_Occurred()) SWIG_fail;
37394 }
37395 {
37396 resultobj = wxPyMake_wxObject(result, 0);
37397 }
37398 {
37399 if (temp1)
37400 delete arg1;
37401 }
37402 return resultobj;
37403 fail:
37404 {
37405 if (temp1)
37406 delete arg1;
37407 }
37408 return NULL;
37409 }
37410
37411
37412 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37413 PyObject *resultobj = 0;
37414 wxWindow *arg1 = (wxWindow *) 0 ;
37415 unsigned long arg2 ;
37416 wxWindow *result = 0 ;
37417 void *argp1 = 0 ;
37418 int res1 = 0 ;
37419 unsigned long val2 ;
37420 int ecode2 = 0 ;
37421 PyObject * obj0 = 0 ;
37422 PyObject * obj1 = 0 ;
37423 char * kwnames[] = {
37424 (char *) "parent",(char *) "_hWnd", NULL
37425 };
37426
37427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37429 if (!SWIG_IsOK(res1)) {
37430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37431 }
37432 arg1 = reinterpret_cast< wxWindow * >(argp1);
37433 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37434 if (!SWIG_IsOK(ecode2)) {
37435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37436 }
37437 arg2 = static_cast< unsigned long >(val2);
37438 {
37439 PyThreadState* __tstate = wxPyBeginAllowThreads();
37440 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37441 wxPyEndAllowThreads(__tstate);
37442 if (PyErr_Occurred()) SWIG_fail;
37443 }
37444 {
37445 resultobj = wxPyMake_wxObject(result, 0);
37446 }
37447 return resultobj;
37448 fail:
37449 return NULL;
37450 }
37451
37452
37453 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37454 PyObject *resultobj = 0;
37455 PyObject *result = 0 ;
37456
37457 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37458 {
37459 PyThreadState* __tstate = wxPyBeginAllowThreads();
37460 result = (PyObject *)GetTopLevelWindows();
37461 wxPyEndAllowThreads(__tstate);
37462 if (PyErr_Occurred()) SWIG_fail;
37463 }
37464 resultobj = result;
37465 return resultobj;
37466 fail:
37467 return NULL;
37468 }
37469
37470
37471 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37472 PyObject *resultobj = 0;
37473 wxValidator *result = 0 ;
37474
37475 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37476 {
37477 PyThreadState* __tstate = wxPyBeginAllowThreads();
37478 result = (wxValidator *)new wxValidator();
37479 wxPyEndAllowThreads(__tstate);
37480 if (PyErr_Occurred()) SWIG_fail;
37481 }
37482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37483 return resultobj;
37484 fail:
37485 return NULL;
37486 }
37487
37488
37489 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37490 PyObject *resultobj = 0;
37491 wxValidator *arg1 = (wxValidator *) 0 ;
37492 wxValidator *result = 0 ;
37493 void *argp1 = 0 ;
37494 int res1 = 0 ;
37495 PyObject *swig_obj[1] ;
37496
37497 if (!args) SWIG_fail;
37498 swig_obj[0] = args;
37499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37500 if (!SWIG_IsOK(res1)) {
37501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37502 }
37503 arg1 = reinterpret_cast< wxValidator * >(argp1);
37504 {
37505 PyThreadState* __tstate = wxPyBeginAllowThreads();
37506 result = (wxValidator *)(arg1)->Clone();
37507 wxPyEndAllowThreads(__tstate);
37508 if (PyErr_Occurred()) SWIG_fail;
37509 }
37510 {
37511 resultobj = wxPyMake_wxObject(result, 0);
37512 }
37513 return resultobj;
37514 fail:
37515 return NULL;
37516 }
37517
37518
37519 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37520 PyObject *resultobj = 0;
37521 wxValidator *arg1 = (wxValidator *) 0 ;
37522 wxWindow *arg2 = (wxWindow *) 0 ;
37523 bool result;
37524 void *argp1 = 0 ;
37525 int res1 = 0 ;
37526 void *argp2 = 0 ;
37527 int res2 = 0 ;
37528 PyObject * obj0 = 0 ;
37529 PyObject * obj1 = 0 ;
37530 char * kwnames[] = {
37531 (char *) "self",(char *) "parent", NULL
37532 };
37533
37534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37536 if (!SWIG_IsOK(res1)) {
37537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37538 }
37539 arg1 = reinterpret_cast< wxValidator * >(argp1);
37540 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37541 if (!SWIG_IsOK(res2)) {
37542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37543 }
37544 arg2 = reinterpret_cast< wxWindow * >(argp2);
37545 {
37546 PyThreadState* __tstate = wxPyBeginAllowThreads();
37547 result = (bool)(arg1)->Validate(arg2);
37548 wxPyEndAllowThreads(__tstate);
37549 if (PyErr_Occurred()) SWIG_fail;
37550 }
37551 {
37552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37553 }
37554 return resultobj;
37555 fail:
37556 return NULL;
37557 }
37558
37559
37560 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37561 PyObject *resultobj = 0;
37562 wxValidator *arg1 = (wxValidator *) 0 ;
37563 bool result;
37564 void *argp1 = 0 ;
37565 int res1 = 0 ;
37566 PyObject *swig_obj[1] ;
37567
37568 if (!args) SWIG_fail;
37569 swig_obj[0] = args;
37570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37571 if (!SWIG_IsOK(res1)) {
37572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37573 }
37574 arg1 = reinterpret_cast< wxValidator * >(argp1);
37575 {
37576 PyThreadState* __tstate = wxPyBeginAllowThreads();
37577 result = (bool)(arg1)->TransferToWindow();
37578 wxPyEndAllowThreads(__tstate);
37579 if (PyErr_Occurred()) SWIG_fail;
37580 }
37581 {
37582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37583 }
37584 return resultobj;
37585 fail:
37586 return NULL;
37587 }
37588
37589
37590 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37591 PyObject *resultobj = 0;
37592 wxValidator *arg1 = (wxValidator *) 0 ;
37593 bool result;
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_wxValidator, 0 | 0 );
37601 if (!SWIG_IsOK(res1)) {
37602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37603 }
37604 arg1 = reinterpret_cast< wxValidator * >(argp1);
37605 {
37606 PyThreadState* __tstate = wxPyBeginAllowThreads();
37607 result = (bool)(arg1)->TransferFromWindow();
37608 wxPyEndAllowThreads(__tstate);
37609 if (PyErr_Occurred()) SWIG_fail;
37610 }
37611 {
37612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37613 }
37614 return resultobj;
37615 fail:
37616 return NULL;
37617 }
37618
37619
37620 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37621 PyObject *resultobj = 0;
37622 wxValidator *arg1 = (wxValidator *) 0 ;
37623 wxWindow *result = 0 ;
37624 void *argp1 = 0 ;
37625 int res1 = 0 ;
37626 PyObject *swig_obj[1] ;
37627
37628 if (!args) SWIG_fail;
37629 swig_obj[0] = args;
37630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37631 if (!SWIG_IsOK(res1)) {
37632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37633 }
37634 arg1 = reinterpret_cast< wxValidator * >(argp1);
37635 {
37636 PyThreadState* __tstate = wxPyBeginAllowThreads();
37637 result = (wxWindow *)(arg1)->GetWindow();
37638 wxPyEndAllowThreads(__tstate);
37639 if (PyErr_Occurred()) SWIG_fail;
37640 }
37641 {
37642 resultobj = wxPyMake_wxObject(result, 0);
37643 }
37644 return resultobj;
37645 fail:
37646 return NULL;
37647 }
37648
37649
37650 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37651 PyObject *resultobj = 0;
37652 wxValidator *arg1 = (wxValidator *) 0 ;
37653 wxWindow *arg2 = (wxWindow *) 0 ;
37654 void *argp1 = 0 ;
37655 int res1 = 0 ;
37656 void *argp2 = 0 ;
37657 int res2 = 0 ;
37658 PyObject * obj0 = 0 ;
37659 PyObject * obj1 = 0 ;
37660 char * kwnames[] = {
37661 (char *) "self",(char *) "window", NULL
37662 };
37663
37664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37666 if (!SWIG_IsOK(res1)) {
37667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37668 }
37669 arg1 = reinterpret_cast< wxValidator * >(argp1);
37670 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37671 if (!SWIG_IsOK(res2)) {
37672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37673 }
37674 arg2 = reinterpret_cast< wxWindow * >(argp2);
37675 {
37676 PyThreadState* __tstate = wxPyBeginAllowThreads();
37677 (arg1)->SetWindow(arg2);
37678 wxPyEndAllowThreads(__tstate);
37679 if (PyErr_Occurred()) SWIG_fail;
37680 }
37681 resultobj = SWIG_Py_Void();
37682 return resultobj;
37683 fail:
37684 return NULL;
37685 }
37686
37687
37688 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37689 PyObject *resultobj = 0;
37690 bool result;
37691
37692 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37693 {
37694 PyThreadState* __tstate = wxPyBeginAllowThreads();
37695 result = (bool)wxValidator::IsSilent();
37696 wxPyEndAllowThreads(__tstate);
37697 if (PyErr_Occurred()) SWIG_fail;
37698 }
37699 {
37700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37701 }
37702 return resultobj;
37703 fail:
37704 return NULL;
37705 }
37706
37707
37708 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37709 PyObject *resultobj = 0;
37710 int arg1 = (int) true ;
37711 int val1 ;
37712 int ecode1 = 0 ;
37713 PyObject * obj0 = 0 ;
37714 char * kwnames[] = {
37715 (char *) "doIt", NULL
37716 };
37717
37718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37719 if (obj0) {
37720 ecode1 = SWIG_AsVal_int(obj0, &val1);
37721 if (!SWIG_IsOK(ecode1)) {
37722 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37723 }
37724 arg1 = static_cast< int >(val1);
37725 }
37726 {
37727 PyThreadState* __tstate = wxPyBeginAllowThreads();
37728 wxValidator::SetBellOnError(arg1);
37729 wxPyEndAllowThreads(__tstate);
37730 if (PyErr_Occurred()) SWIG_fail;
37731 }
37732 resultobj = SWIG_Py_Void();
37733 return resultobj;
37734 fail:
37735 return NULL;
37736 }
37737
37738
37739 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37740 PyObject *obj;
37741 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37742 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37743 return SWIG_Py_Void();
37744 }
37745
37746 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37747 return SWIG_Python_InitShadowInstance(args);
37748 }
37749
37750 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37751 PyObject *resultobj = 0;
37752 wxPyValidator *result = 0 ;
37753
37754 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37755 {
37756 PyThreadState* __tstate = wxPyBeginAllowThreads();
37757 result = (wxPyValidator *)new wxPyValidator();
37758 wxPyEndAllowThreads(__tstate);
37759 if (PyErr_Occurred()) SWIG_fail;
37760 }
37761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37762 return resultobj;
37763 fail:
37764 return NULL;
37765 }
37766
37767
37768 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37769 PyObject *resultobj = 0;
37770 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37771 PyObject *arg2 = (PyObject *) 0 ;
37772 PyObject *arg3 = (PyObject *) 0 ;
37773 int arg4 = (int) true ;
37774 void *argp1 = 0 ;
37775 int res1 = 0 ;
37776 int val4 ;
37777 int ecode4 = 0 ;
37778 PyObject * obj0 = 0 ;
37779 PyObject * obj1 = 0 ;
37780 PyObject * obj2 = 0 ;
37781 PyObject * obj3 = 0 ;
37782 char * kwnames[] = {
37783 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37784 };
37785
37786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37788 if (!SWIG_IsOK(res1)) {
37789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37790 }
37791 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37792 arg2 = obj1;
37793 arg3 = obj2;
37794 if (obj3) {
37795 ecode4 = SWIG_AsVal_int(obj3, &val4);
37796 if (!SWIG_IsOK(ecode4)) {
37797 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37798 }
37799 arg4 = static_cast< int >(val4);
37800 }
37801 {
37802 PyThreadState* __tstate = wxPyBeginAllowThreads();
37803 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
37804 wxPyEndAllowThreads(__tstate);
37805 if (PyErr_Occurred()) SWIG_fail;
37806 }
37807 resultobj = SWIG_Py_Void();
37808 return resultobj;
37809 fail:
37810 return NULL;
37811 }
37812
37813
37814 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37815 PyObject *obj;
37816 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37817 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
37818 return SWIG_Py_Void();
37819 }
37820
37821 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37822 return SWIG_Python_InitShadowInstance(args);
37823 }
37824
37825 SWIGINTERN int DefaultValidator_set(PyObject *) {
37826 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
37827 return 1;
37828 }
37829
37830
37831 SWIGINTERN PyObject *DefaultValidator_get(void) {
37832 PyObject *pyobj = 0;
37833
37834 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
37835 return pyobj;
37836 }
37837
37838
37839 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37840 PyObject *resultobj = 0;
37841 wxString const &arg1_defvalue = wxPyEmptyString ;
37842 wxString *arg1 = (wxString *) &arg1_defvalue ;
37843 long arg2 = (long) 0 ;
37844 wxMenu *result = 0 ;
37845 bool temp1 = false ;
37846 long val2 ;
37847 int ecode2 = 0 ;
37848 PyObject * obj0 = 0 ;
37849 PyObject * obj1 = 0 ;
37850 char * kwnames[] = {
37851 (char *) "title",(char *) "style", NULL
37852 };
37853
37854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
37855 if (obj0) {
37856 {
37857 arg1 = wxString_in_helper(obj0);
37858 if (arg1 == NULL) SWIG_fail;
37859 temp1 = true;
37860 }
37861 }
37862 if (obj1) {
37863 ecode2 = SWIG_AsVal_long(obj1, &val2);
37864 if (!SWIG_IsOK(ecode2)) {
37865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
37866 }
37867 arg2 = static_cast< long >(val2);
37868 }
37869 {
37870 if (!wxPyCheckForApp()) SWIG_fail;
37871 PyThreadState* __tstate = wxPyBeginAllowThreads();
37872 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
37873 wxPyEndAllowThreads(__tstate);
37874 if (PyErr_Occurred()) SWIG_fail;
37875 }
37876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
37877 {
37878 if (temp1)
37879 delete arg1;
37880 }
37881 return resultobj;
37882 fail:
37883 {
37884 if (temp1)
37885 delete arg1;
37886 }
37887 return NULL;
37888 }
37889
37890
37891 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37892 PyObject *resultobj = 0;
37893 wxMenu *arg1 = (wxMenu *) 0 ;
37894 int arg2 ;
37895 wxString *arg3 = 0 ;
37896 wxString const &arg4_defvalue = wxPyEmptyString ;
37897 wxString *arg4 = (wxString *) &arg4_defvalue ;
37898 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
37899 wxMenuItem *result = 0 ;
37900 void *argp1 = 0 ;
37901 int res1 = 0 ;
37902 int val2 ;
37903 int ecode2 = 0 ;
37904 bool temp3 = false ;
37905 bool temp4 = false ;
37906 int val5 ;
37907 int ecode5 = 0 ;
37908 PyObject * obj0 = 0 ;
37909 PyObject * obj1 = 0 ;
37910 PyObject * obj2 = 0 ;
37911 PyObject * obj3 = 0 ;
37912 PyObject * obj4 = 0 ;
37913 char * kwnames[] = {
37914 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
37915 };
37916
37917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
37919 if (!SWIG_IsOK(res1)) {
37920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
37921 }
37922 arg1 = reinterpret_cast< wxMenu * >(argp1);
37923 ecode2 = SWIG_AsVal_int(obj1, &val2);
37924 if (!SWIG_IsOK(ecode2)) {
37925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
37926 }
37927 arg2 = static_cast< int >(val2);
37928 {
37929 arg3 = wxString_in_helper(obj2);
37930 if (arg3 == NULL) SWIG_fail;
37931 temp3 = true;
37932 }
37933 if (obj3) {
37934 {
37935 arg4 = wxString_in_helper(obj3);
37936 if (arg4 == NULL) SWIG_fail;
37937 temp4 = true;
37938 }
37939 }
37940 if (obj4) {
37941 ecode5 = SWIG_AsVal_int(obj4, &val5);
37942 if (!SWIG_IsOK(ecode5)) {
37943 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
37944 }
37945 arg5 = static_cast< wxItemKind >(val5);
37946 }
37947 {
37948 PyThreadState* __tstate = wxPyBeginAllowThreads();
37949 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
37950 wxPyEndAllowThreads(__tstate);
37951 if (PyErr_Occurred()) SWIG_fail;
37952 }
37953 {
37954 resultobj = wxPyMake_wxObject(result, (bool)0);
37955 }
37956 {
37957 if (temp3)
37958 delete arg3;
37959 }
37960 {
37961 if (temp4)
37962 delete arg4;
37963 }
37964 return resultobj;
37965 fail:
37966 {
37967 if (temp3)
37968 delete arg3;
37969 }
37970 {
37971 if (temp4)
37972 delete arg4;
37973 }
37974 return NULL;
37975 }
37976
37977
37978 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37979 PyObject *resultobj = 0;
37980 wxMenu *arg1 = (wxMenu *) 0 ;
37981 wxMenuItem *result = 0 ;
37982 void *argp1 = 0 ;
37983 int res1 = 0 ;
37984 PyObject *swig_obj[1] ;
37985
37986 if (!args) SWIG_fail;
37987 swig_obj[0] = args;
37988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
37989 if (!SWIG_IsOK(res1)) {
37990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
37991 }
37992 arg1 = reinterpret_cast< wxMenu * >(argp1);
37993 {
37994 PyThreadState* __tstate = wxPyBeginAllowThreads();
37995 result = (wxMenuItem *)(arg1)->AppendSeparator();
37996 wxPyEndAllowThreads(__tstate);
37997 if (PyErr_Occurred()) SWIG_fail;
37998 }
37999 {
38000 resultobj = wxPyMake_wxObject(result, (bool)0);
38001 }
38002 return resultobj;
38003 fail:
38004 return NULL;
38005 }
38006
38007
38008 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38009 PyObject *resultobj = 0;
38010 wxMenu *arg1 = (wxMenu *) 0 ;
38011 int arg2 ;
38012 wxString *arg3 = 0 ;
38013 wxString const &arg4_defvalue = wxPyEmptyString ;
38014 wxString *arg4 = (wxString *) &arg4_defvalue ;
38015 wxMenuItem *result = 0 ;
38016 void *argp1 = 0 ;
38017 int res1 = 0 ;
38018 int val2 ;
38019 int ecode2 = 0 ;
38020 bool temp3 = false ;
38021 bool temp4 = false ;
38022 PyObject * obj0 = 0 ;
38023 PyObject * obj1 = 0 ;
38024 PyObject * obj2 = 0 ;
38025 PyObject * obj3 = 0 ;
38026 char * kwnames[] = {
38027 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38028 };
38029
38030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38032 if (!SWIG_IsOK(res1)) {
38033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38034 }
38035 arg1 = reinterpret_cast< wxMenu * >(argp1);
38036 ecode2 = SWIG_AsVal_int(obj1, &val2);
38037 if (!SWIG_IsOK(ecode2)) {
38038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38039 }
38040 arg2 = static_cast< int >(val2);
38041 {
38042 arg3 = wxString_in_helper(obj2);
38043 if (arg3 == NULL) SWIG_fail;
38044 temp3 = true;
38045 }
38046 if (obj3) {
38047 {
38048 arg4 = wxString_in_helper(obj3);
38049 if (arg4 == NULL) SWIG_fail;
38050 temp4 = true;
38051 }
38052 }
38053 {
38054 PyThreadState* __tstate = wxPyBeginAllowThreads();
38055 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38056 wxPyEndAllowThreads(__tstate);
38057 if (PyErr_Occurred()) SWIG_fail;
38058 }
38059 {
38060 resultobj = wxPyMake_wxObject(result, (bool)0);
38061 }
38062 {
38063 if (temp3)
38064 delete arg3;
38065 }
38066 {
38067 if (temp4)
38068 delete arg4;
38069 }
38070 return resultobj;
38071 fail:
38072 {
38073 if (temp3)
38074 delete arg3;
38075 }
38076 {
38077 if (temp4)
38078 delete arg4;
38079 }
38080 return NULL;
38081 }
38082
38083
38084 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38085 PyObject *resultobj = 0;
38086 wxMenu *arg1 = (wxMenu *) 0 ;
38087 int arg2 ;
38088 wxString *arg3 = 0 ;
38089 wxString const &arg4_defvalue = wxPyEmptyString ;
38090 wxString *arg4 = (wxString *) &arg4_defvalue ;
38091 wxMenuItem *result = 0 ;
38092 void *argp1 = 0 ;
38093 int res1 = 0 ;
38094 int val2 ;
38095 int ecode2 = 0 ;
38096 bool temp3 = false ;
38097 bool temp4 = false ;
38098 PyObject * obj0 = 0 ;
38099 PyObject * obj1 = 0 ;
38100 PyObject * obj2 = 0 ;
38101 PyObject * obj3 = 0 ;
38102 char * kwnames[] = {
38103 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38104 };
38105
38106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38108 if (!SWIG_IsOK(res1)) {
38109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38110 }
38111 arg1 = reinterpret_cast< wxMenu * >(argp1);
38112 ecode2 = SWIG_AsVal_int(obj1, &val2);
38113 if (!SWIG_IsOK(ecode2)) {
38114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38115 }
38116 arg2 = static_cast< int >(val2);
38117 {
38118 arg3 = wxString_in_helper(obj2);
38119 if (arg3 == NULL) SWIG_fail;
38120 temp3 = true;
38121 }
38122 if (obj3) {
38123 {
38124 arg4 = wxString_in_helper(obj3);
38125 if (arg4 == NULL) SWIG_fail;
38126 temp4 = true;
38127 }
38128 }
38129 {
38130 PyThreadState* __tstate = wxPyBeginAllowThreads();
38131 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38132 wxPyEndAllowThreads(__tstate);
38133 if (PyErr_Occurred()) SWIG_fail;
38134 }
38135 {
38136 resultobj = wxPyMake_wxObject(result, (bool)0);
38137 }
38138 {
38139 if (temp3)
38140 delete arg3;
38141 }
38142 {
38143 if (temp4)
38144 delete arg4;
38145 }
38146 return resultobj;
38147 fail:
38148 {
38149 if (temp3)
38150 delete arg3;
38151 }
38152 {
38153 if (temp4)
38154 delete arg4;
38155 }
38156 return NULL;
38157 }
38158
38159
38160 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38161 PyObject *resultobj = 0;
38162 wxMenu *arg1 = (wxMenu *) 0 ;
38163 int arg2 ;
38164 wxString *arg3 = 0 ;
38165 wxMenu *arg4 = (wxMenu *) 0 ;
38166 wxString const &arg5_defvalue = wxPyEmptyString ;
38167 wxString *arg5 = (wxString *) &arg5_defvalue ;
38168 wxMenuItem *result = 0 ;
38169 void *argp1 = 0 ;
38170 int res1 = 0 ;
38171 int val2 ;
38172 int ecode2 = 0 ;
38173 bool temp3 = false ;
38174 void *argp4 = 0 ;
38175 int res4 = 0 ;
38176 bool temp5 = false ;
38177 PyObject * obj0 = 0 ;
38178 PyObject * obj1 = 0 ;
38179 PyObject * obj2 = 0 ;
38180 PyObject * obj3 = 0 ;
38181 PyObject * obj4 = 0 ;
38182 char * kwnames[] = {
38183 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38184 };
38185
38186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38188 if (!SWIG_IsOK(res1)) {
38189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38190 }
38191 arg1 = reinterpret_cast< wxMenu * >(argp1);
38192 ecode2 = SWIG_AsVal_int(obj1, &val2);
38193 if (!SWIG_IsOK(ecode2)) {
38194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38195 }
38196 arg2 = static_cast< int >(val2);
38197 {
38198 arg3 = wxString_in_helper(obj2);
38199 if (arg3 == NULL) SWIG_fail;
38200 temp3 = true;
38201 }
38202 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38203 if (!SWIG_IsOK(res4)) {
38204 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38205 }
38206 arg4 = reinterpret_cast< wxMenu * >(argp4);
38207 if (obj4) {
38208 {
38209 arg5 = wxString_in_helper(obj4);
38210 if (arg5 == NULL) SWIG_fail;
38211 temp5 = true;
38212 }
38213 }
38214 {
38215 PyThreadState* __tstate = wxPyBeginAllowThreads();
38216 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38217 wxPyEndAllowThreads(__tstate);
38218 if (PyErr_Occurred()) SWIG_fail;
38219 }
38220 {
38221 resultobj = wxPyMake_wxObject(result, (bool)0);
38222 }
38223 {
38224 if (temp3)
38225 delete arg3;
38226 }
38227 {
38228 if (temp5)
38229 delete arg5;
38230 }
38231 return resultobj;
38232 fail:
38233 {
38234 if (temp3)
38235 delete arg3;
38236 }
38237 {
38238 if (temp5)
38239 delete arg5;
38240 }
38241 return NULL;
38242 }
38243
38244
38245 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38246 PyObject *resultobj = 0;
38247 wxMenu *arg1 = (wxMenu *) 0 ;
38248 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38249 wxMenuItem *result = 0 ;
38250 void *argp1 = 0 ;
38251 int res1 = 0 ;
38252 int res2 = 0 ;
38253 PyObject * obj0 = 0 ;
38254 PyObject * obj1 = 0 ;
38255 char * kwnames[] = {
38256 (char *) "self",(char *) "item", NULL
38257 };
38258
38259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38261 if (!SWIG_IsOK(res1)) {
38262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38263 }
38264 arg1 = reinterpret_cast< wxMenu * >(argp1);
38265 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38266 if (!SWIG_IsOK(res2)) {
38267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38268 }
38269 {
38270 PyThreadState* __tstate = wxPyBeginAllowThreads();
38271 result = (wxMenuItem *)(arg1)->Append(arg2);
38272 wxPyEndAllowThreads(__tstate);
38273 if (PyErr_Occurred()) SWIG_fail;
38274 }
38275 {
38276 resultobj = wxPyMake_wxObject(result, (bool)0);
38277 }
38278 return resultobj;
38279 fail:
38280 return NULL;
38281 }
38282
38283
38284 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38285 PyObject *resultobj = 0;
38286 wxMenu *arg1 = (wxMenu *) 0 ;
38287 size_t arg2 ;
38288 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38289 wxMenuItem *result = 0 ;
38290 void *argp1 = 0 ;
38291 int res1 = 0 ;
38292 size_t val2 ;
38293 int ecode2 = 0 ;
38294 int res3 = 0 ;
38295 PyObject * obj0 = 0 ;
38296 PyObject * obj1 = 0 ;
38297 PyObject * obj2 = 0 ;
38298 char * kwnames[] = {
38299 (char *) "self",(char *) "pos",(char *) "item", NULL
38300 };
38301
38302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38304 if (!SWIG_IsOK(res1)) {
38305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38306 }
38307 arg1 = reinterpret_cast< wxMenu * >(argp1);
38308 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38309 if (!SWIG_IsOK(ecode2)) {
38310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38311 }
38312 arg2 = static_cast< size_t >(val2);
38313 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38314 if (!SWIG_IsOK(res3)) {
38315 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38316 }
38317 {
38318 PyThreadState* __tstate = wxPyBeginAllowThreads();
38319 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38320 wxPyEndAllowThreads(__tstate);
38321 if (PyErr_Occurred()) SWIG_fail;
38322 }
38323 {
38324 resultobj = wxPyMake_wxObject(result, (bool)0);
38325 }
38326 return resultobj;
38327 fail:
38328 return NULL;
38329 }
38330
38331
38332 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38333 PyObject *resultobj = 0;
38334 wxMenu *arg1 = (wxMenu *) 0 ;
38335 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38336 wxMenuItem *result = 0 ;
38337 void *argp1 = 0 ;
38338 int res1 = 0 ;
38339 int res2 = 0 ;
38340 PyObject * obj0 = 0 ;
38341 PyObject * obj1 = 0 ;
38342 char * kwnames[] = {
38343 (char *) "self",(char *) "item", NULL
38344 };
38345
38346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38348 if (!SWIG_IsOK(res1)) {
38349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38350 }
38351 arg1 = reinterpret_cast< wxMenu * >(argp1);
38352 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38353 if (!SWIG_IsOK(res2)) {
38354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38355 }
38356 {
38357 PyThreadState* __tstate = wxPyBeginAllowThreads();
38358 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38359 wxPyEndAllowThreads(__tstate);
38360 if (PyErr_Occurred()) SWIG_fail;
38361 }
38362 {
38363 resultobj = wxPyMake_wxObject(result, (bool)0);
38364 }
38365 return resultobj;
38366 fail:
38367 return NULL;
38368 }
38369
38370
38371 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38372 PyObject *resultobj = 0;
38373 wxMenu *arg1 = (wxMenu *) 0 ;
38374 void *argp1 = 0 ;
38375 int res1 = 0 ;
38376 PyObject *swig_obj[1] ;
38377
38378 if (!args) SWIG_fail;
38379 swig_obj[0] = args;
38380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38381 if (!SWIG_IsOK(res1)) {
38382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38383 }
38384 arg1 = reinterpret_cast< wxMenu * >(argp1);
38385 {
38386 PyThreadState* __tstate = wxPyBeginAllowThreads();
38387 (arg1)->Break();
38388 wxPyEndAllowThreads(__tstate);
38389 if (PyErr_Occurred()) SWIG_fail;
38390 }
38391 resultobj = SWIG_Py_Void();
38392 return resultobj;
38393 fail:
38394 return NULL;
38395 }
38396
38397
38398 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38399 PyObject *resultobj = 0;
38400 wxMenu *arg1 = (wxMenu *) 0 ;
38401 size_t arg2 ;
38402 int arg3 ;
38403 wxString *arg4 = 0 ;
38404 wxString const &arg5_defvalue = wxPyEmptyString ;
38405 wxString *arg5 = (wxString *) &arg5_defvalue ;
38406 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38407 wxMenuItem *result = 0 ;
38408 void *argp1 = 0 ;
38409 int res1 = 0 ;
38410 size_t val2 ;
38411 int ecode2 = 0 ;
38412 int val3 ;
38413 int ecode3 = 0 ;
38414 bool temp4 = false ;
38415 bool temp5 = false ;
38416 int val6 ;
38417 int ecode6 = 0 ;
38418 PyObject * obj0 = 0 ;
38419 PyObject * obj1 = 0 ;
38420 PyObject * obj2 = 0 ;
38421 PyObject * obj3 = 0 ;
38422 PyObject * obj4 = 0 ;
38423 PyObject * obj5 = 0 ;
38424 char * kwnames[] = {
38425 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38426 };
38427
38428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38430 if (!SWIG_IsOK(res1)) {
38431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38432 }
38433 arg1 = reinterpret_cast< wxMenu * >(argp1);
38434 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38435 if (!SWIG_IsOK(ecode2)) {
38436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38437 }
38438 arg2 = static_cast< size_t >(val2);
38439 ecode3 = SWIG_AsVal_int(obj2, &val3);
38440 if (!SWIG_IsOK(ecode3)) {
38441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38442 }
38443 arg3 = static_cast< int >(val3);
38444 {
38445 arg4 = wxString_in_helper(obj3);
38446 if (arg4 == NULL) SWIG_fail;
38447 temp4 = true;
38448 }
38449 if (obj4) {
38450 {
38451 arg5 = wxString_in_helper(obj4);
38452 if (arg5 == NULL) SWIG_fail;
38453 temp5 = true;
38454 }
38455 }
38456 if (obj5) {
38457 ecode6 = SWIG_AsVal_int(obj5, &val6);
38458 if (!SWIG_IsOK(ecode6)) {
38459 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38460 }
38461 arg6 = static_cast< wxItemKind >(val6);
38462 }
38463 {
38464 PyThreadState* __tstate = wxPyBeginAllowThreads();
38465 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38466 wxPyEndAllowThreads(__tstate);
38467 if (PyErr_Occurred()) SWIG_fail;
38468 }
38469 {
38470 resultobj = wxPyMake_wxObject(result, (bool)0);
38471 }
38472 {
38473 if (temp4)
38474 delete arg4;
38475 }
38476 {
38477 if (temp5)
38478 delete arg5;
38479 }
38480 return resultobj;
38481 fail:
38482 {
38483 if (temp4)
38484 delete arg4;
38485 }
38486 {
38487 if (temp5)
38488 delete arg5;
38489 }
38490 return NULL;
38491 }
38492
38493
38494 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38495 PyObject *resultobj = 0;
38496 wxMenu *arg1 = (wxMenu *) 0 ;
38497 size_t arg2 ;
38498 wxMenuItem *result = 0 ;
38499 void *argp1 = 0 ;
38500 int res1 = 0 ;
38501 size_t val2 ;
38502 int ecode2 = 0 ;
38503 PyObject * obj0 = 0 ;
38504 PyObject * obj1 = 0 ;
38505 char * kwnames[] = {
38506 (char *) "self",(char *) "pos", NULL
38507 };
38508
38509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38511 if (!SWIG_IsOK(res1)) {
38512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38513 }
38514 arg1 = reinterpret_cast< wxMenu * >(argp1);
38515 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38516 if (!SWIG_IsOK(ecode2)) {
38517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38518 }
38519 arg2 = static_cast< size_t >(val2);
38520 {
38521 PyThreadState* __tstate = wxPyBeginAllowThreads();
38522 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38523 wxPyEndAllowThreads(__tstate);
38524 if (PyErr_Occurred()) SWIG_fail;
38525 }
38526 {
38527 resultobj = wxPyMake_wxObject(result, (bool)0);
38528 }
38529 return resultobj;
38530 fail:
38531 return NULL;
38532 }
38533
38534
38535 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38536 PyObject *resultobj = 0;
38537 wxMenu *arg1 = (wxMenu *) 0 ;
38538 size_t arg2 ;
38539 int arg3 ;
38540 wxString *arg4 = 0 ;
38541 wxString const &arg5_defvalue = wxPyEmptyString ;
38542 wxString *arg5 = (wxString *) &arg5_defvalue ;
38543 wxMenuItem *result = 0 ;
38544 void *argp1 = 0 ;
38545 int res1 = 0 ;
38546 size_t val2 ;
38547 int ecode2 = 0 ;
38548 int val3 ;
38549 int ecode3 = 0 ;
38550 bool temp4 = false ;
38551 bool temp5 = false ;
38552 PyObject * obj0 = 0 ;
38553 PyObject * obj1 = 0 ;
38554 PyObject * obj2 = 0 ;
38555 PyObject * obj3 = 0 ;
38556 PyObject * obj4 = 0 ;
38557 char * kwnames[] = {
38558 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38559 };
38560
38561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38563 if (!SWIG_IsOK(res1)) {
38564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38565 }
38566 arg1 = reinterpret_cast< wxMenu * >(argp1);
38567 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38568 if (!SWIG_IsOK(ecode2)) {
38569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38570 }
38571 arg2 = static_cast< size_t >(val2);
38572 ecode3 = SWIG_AsVal_int(obj2, &val3);
38573 if (!SWIG_IsOK(ecode3)) {
38574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38575 }
38576 arg3 = static_cast< int >(val3);
38577 {
38578 arg4 = wxString_in_helper(obj3);
38579 if (arg4 == NULL) SWIG_fail;
38580 temp4 = true;
38581 }
38582 if (obj4) {
38583 {
38584 arg5 = wxString_in_helper(obj4);
38585 if (arg5 == NULL) SWIG_fail;
38586 temp5 = true;
38587 }
38588 }
38589 {
38590 PyThreadState* __tstate = wxPyBeginAllowThreads();
38591 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38592 wxPyEndAllowThreads(__tstate);
38593 if (PyErr_Occurred()) SWIG_fail;
38594 }
38595 {
38596 resultobj = wxPyMake_wxObject(result, (bool)0);
38597 }
38598 {
38599 if (temp4)
38600 delete arg4;
38601 }
38602 {
38603 if (temp5)
38604 delete arg5;
38605 }
38606 return resultobj;
38607 fail:
38608 {
38609 if (temp4)
38610 delete arg4;
38611 }
38612 {
38613 if (temp5)
38614 delete arg5;
38615 }
38616 return NULL;
38617 }
38618
38619
38620 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38621 PyObject *resultobj = 0;
38622 wxMenu *arg1 = (wxMenu *) 0 ;
38623 size_t arg2 ;
38624 int arg3 ;
38625 wxString *arg4 = 0 ;
38626 wxString const &arg5_defvalue = wxPyEmptyString ;
38627 wxString *arg5 = (wxString *) &arg5_defvalue ;
38628 wxMenuItem *result = 0 ;
38629 void *argp1 = 0 ;
38630 int res1 = 0 ;
38631 size_t val2 ;
38632 int ecode2 = 0 ;
38633 int val3 ;
38634 int ecode3 = 0 ;
38635 bool temp4 = false ;
38636 bool temp5 = false ;
38637 PyObject * obj0 = 0 ;
38638 PyObject * obj1 = 0 ;
38639 PyObject * obj2 = 0 ;
38640 PyObject * obj3 = 0 ;
38641 PyObject * obj4 = 0 ;
38642 char * kwnames[] = {
38643 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38644 };
38645
38646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38648 if (!SWIG_IsOK(res1)) {
38649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38650 }
38651 arg1 = reinterpret_cast< wxMenu * >(argp1);
38652 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38653 if (!SWIG_IsOK(ecode2)) {
38654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38655 }
38656 arg2 = static_cast< size_t >(val2);
38657 ecode3 = SWIG_AsVal_int(obj2, &val3);
38658 if (!SWIG_IsOK(ecode3)) {
38659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38660 }
38661 arg3 = static_cast< int >(val3);
38662 {
38663 arg4 = wxString_in_helper(obj3);
38664 if (arg4 == NULL) SWIG_fail;
38665 temp4 = true;
38666 }
38667 if (obj4) {
38668 {
38669 arg5 = wxString_in_helper(obj4);
38670 if (arg5 == NULL) SWIG_fail;
38671 temp5 = true;
38672 }
38673 }
38674 {
38675 PyThreadState* __tstate = wxPyBeginAllowThreads();
38676 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38677 wxPyEndAllowThreads(__tstate);
38678 if (PyErr_Occurred()) SWIG_fail;
38679 }
38680 {
38681 resultobj = wxPyMake_wxObject(result, (bool)0);
38682 }
38683 {
38684 if (temp4)
38685 delete arg4;
38686 }
38687 {
38688 if (temp5)
38689 delete arg5;
38690 }
38691 return resultobj;
38692 fail:
38693 {
38694 if (temp4)
38695 delete arg4;
38696 }
38697 {
38698 if (temp5)
38699 delete arg5;
38700 }
38701 return NULL;
38702 }
38703
38704
38705 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38706 PyObject *resultobj = 0;
38707 wxMenu *arg1 = (wxMenu *) 0 ;
38708 size_t arg2 ;
38709 int arg3 ;
38710 wxString *arg4 = 0 ;
38711 wxMenu *arg5 = (wxMenu *) 0 ;
38712 wxString const &arg6_defvalue = wxPyEmptyString ;
38713 wxString *arg6 = (wxString *) &arg6_defvalue ;
38714 wxMenuItem *result = 0 ;
38715 void *argp1 = 0 ;
38716 int res1 = 0 ;
38717 size_t val2 ;
38718 int ecode2 = 0 ;
38719 int val3 ;
38720 int ecode3 = 0 ;
38721 bool temp4 = false ;
38722 void *argp5 = 0 ;
38723 int res5 = 0 ;
38724 bool temp6 = false ;
38725 PyObject * obj0 = 0 ;
38726 PyObject * obj1 = 0 ;
38727 PyObject * obj2 = 0 ;
38728 PyObject * obj3 = 0 ;
38729 PyObject * obj4 = 0 ;
38730 PyObject * obj5 = 0 ;
38731 char * kwnames[] = {
38732 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38733 };
38734
38735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38737 if (!SWIG_IsOK(res1)) {
38738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38739 }
38740 arg1 = reinterpret_cast< wxMenu * >(argp1);
38741 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38742 if (!SWIG_IsOK(ecode2)) {
38743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
38744 }
38745 arg2 = static_cast< size_t >(val2);
38746 ecode3 = SWIG_AsVal_int(obj2, &val3);
38747 if (!SWIG_IsOK(ecode3)) {
38748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
38749 }
38750 arg3 = static_cast< int >(val3);
38751 {
38752 arg4 = wxString_in_helper(obj3);
38753 if (arg4 == NULL) SWIG_fail;
38754 temp4 = true;
38755 }
38756 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
38757 if (!SWIG_IsOK(res5)) {
38758 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
38759 }
38760 arg5 = reinterpret_cast< wxMenu * >(argp5);
38761 if (obj5) {
38762 {
38763 arg6 = wxString_in_helper(obj5);
38764 if (arg6 == NULL) SWIG_fail;
38765 temp6 = true;
38766 }
38767 }
38768 {
38769 PyThreadState* __tstate = wxPyBeginAllowThreads();
38770 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
38771 wxPyEndAllowThreads(__tstate);
38772 if (PyErr_Occurred()) SWIG_fail;
38773 }
38774 {
38775 resultobj = wxPyMake_wxObject(result, (bool)0);
38776 }
38777 {
38778 if (temp4)
38779 delete arg4;
38780 }
38781 {
38782 if (temp6)
38783 delete arg6;
38784 }
38785 return resultobj;
38786 fail:
38787 {
38788 if (temp4)
38789 delete arg4;
38790 }
38791 {
38792 if (temp6)
38793 delete arg6;
38794 }
38795 return NULL;
38796 }
38797
38798
38799 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38800 PyObject *resultobj = 0;
38801 wxMenu *arg1 = (wxMenu *) 0 ;
38802 int arg2 ;
38803 wxString *arg3 = 0 ;
38804 wxString const &arg4_defvalue = wxPyEmptyString ;
38805 wxString *arg4 = (wxString *) &arg4_defvalue ;
38806 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38807 wxMenuItem *result = 0 ;
38808 void *argp1 = 0 ;
38809 int res1 = 0 ;
38810 int val2 ;
38811 int ecode2 = 0 ;
38812 bool temp3 = false ;
38813 bool temp4 = false ;
38814 int val5 ;
38815 int ecode5 = 0 ;
38816 PyObject * obj0 = 0 ;
38817 PyObject * obj1 = 0 ;
38818 PyObject * obj2 = 0 ;
38819 PyObject * obj3 = 0 ;
38820 PyObject * obj4 = 0 ;
38821 char * kwnames[] = {
38822 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38823 };
38824
38825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38827 if (!SWIG_IsOK(res1)) {
38828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
38829 }
38830 arg1 = reinterpret_cast< wxMenu * >(argp1);
38831 ecode2 = SWIG_AsVal_int(obj1, &val2);
38832 if (!SWIG_IsOK(ecode2)) {
38833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
38834 }
38835 arg2 = static_cast< int >(val2);
38836 {
38837 arg3 = wxString_in_helper(obj2);
38838 if (arg3 == NULL) SWIG_fail;
38839 temp3 = true;
38840 }
38841 if (obj3) {
38842 {
38843 arg4 = wxString_in_helper(obj3);
38844 if (arg4 == NULL) SWIG_fail;
38845 temp4 = true;
38846 }
38847 }
38848 if (obj4) {
38849 ecode5 = SWIG_AsVal_int(obj4, &val5);
38850 if (!SWIG_IsOK(ecode5)) {
38851 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
38852 }
38853 arg5 = static_cast< wxItemKind >(val5);
38854 }
38855 {
38856 PyThreadState* __tstate = wxPyBeginAllowThreads();
38857 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38858 wxPyEndAllowThreads(__tstate);
38859 if (PyErr_Occurred()) SWIG_fail;
38860 }
38861 {
38862 resultobj = wxPyMake_wxObject(result, (bool)0);
38863 }
38864 {
38865 if (temp3)
38866 delete arg3;
38867 }
38868 {
38869 if (temp4)
38870 delete arg4;
38871 }
38872 return resultobj;
38873 fail:
38874 {
38875 if (temp3)
38876 delete arg3;
38877 }
38878 {
38879 if (temp4)
38880 delete arg4;
38881 }
38882 return NULL;
38883 }
38884
38885
38886 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38887 PyObject *resultobj = 0;
38888 wxMenu *arg1 = (wxMenu *) 0 ;
38889 wxMenuItem *result = 0 ;
38890 void *argp1 = 0 ;
38891 int res1 = 0 ;
38892 PyObject *swig_obj[1] ;
38893
38894 if (!args) SWIG_fail;
38895 swig_obj[0] = args;
38896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38897 if (!SWIG_IsOK(res1)) {
38898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38899 }
38900 arg1 = reinterpret_cast< wxMenu * >(argp1);
38901 {
38902 PyThreadState* __tstate = wxPyBeginAllowThreads();
38903 result = (wxMenuItem *)(arg1)->PrependSeparator();
38904 wxPyEndAllowThreads(__tstate);
38905 if (PyErr_Occurred()) SWIG_fail;
38906 }
38907 {
38908 resultobj = wxPyMake_wxObject(result, (bool)0);
38909 }
38910 return resultobj;
38911 fail:
38912 return NULL;
38913 }
38914
38915
38916 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38917 PyObject *resultobj = 0;
38918 wxMenu *arg1 = (wxMenu *) 0 ;
38919 int arg2 ;
38920 wxString *arg3 = 0 ;
38921 wxString const &arg4_defvalue = wxPyEmptyString ;
38922 wxString *arg4 = (wxString *) &arg4_defvalue ;
38923 wxMenuItem *result = 0 ;
38924 void *argp1 = 0 ;
38925 int res1 = 0 ;
38926 int val2 ;
38927 int ecode2 = 0 ;
38928 bool temp3 = false ;
38929 bool temp4 = false ;
38930 PyObject * obj0 = 0 ;
38931 PyObject * obj1 = 0 ;
38932 PyObject * obj2 = 0 ;
38933 PyObject * obj3 = 0 ;
38934 char * kwnames[] = {
38935 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38936 };
38937
38938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38940 if (!SWIG_IsOK(res1)) {
38941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38942 }
38943 arg1 = reinterpret_cast< wxMenu * >(argp1);
38944 ecode2 = SWIG_AsVal_int(obj1, &val2);
38945 if (!SWIG_IsOK(ecode2)) {
38946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
38947 }
38948 arg2 = static_cast< int >(val2);
38949 {
38950 arg3 = wxString_in_helper(obj2);
38951 if (arg3 == NULL) SWIG_fail;
38952 temp3 = true;
38953 }
38954 if (obj3) {
38955 {
38956 arg4 = wxString_in_helper(obj3);
38957 if (arg4 == NULL) SWIG_fail;
38958 temp4 = true;
38959 }
38960 }
38961 {
38962 PyThreadState* __tstate = wxPyBeginAllowThreads();
38963 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38964 wxPyEndAllowThreads(__tstate);
38965 if (PyErr_Occurred()) SWIG_fail;
38966 }
38967 {
38968 resultobj = wxPyMake_wxObject(result, (bool)0);
38969 }
38970 {
38971 if (temp3)
38972 delete arg3;
38973 }
38974 {
38975 if (temp4)
38976 delete arg4;
38977 }
38978 return resultobj;
38979 fail:
38980 {
38981 if (temp3)
38982 delete arg3;
38983 }
38984 {
38985 if (temp4)
38986 delete arg4;
38987 }
38988 return NULL;
38989 }
38990
38991
38992 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38993 PyObject *resultobj = 0;
38994 wxMenu *arg1 = (wxMenu *) 0 ;
38995 int arg2 ;
38996 wxString *arg3 = 0 ;
38997 wxString const &arg4_defvalue = wxPyEmptyString ;
38998 wxString *arg4 = (wxString *) &arg4_defvalue ;
38999 wxMenuItem *result = 0 ;
39000 void *argp1 = 0 ;
39001 int res1 = 0 ;
39002 int val2 ;
39003 int ecode2 = 0 ;
39004 bool temp3 = false ;
39005 bool temp4 = false ;
39006 PyObject * obj0 = 0 ;
39007 PyObject * obj1 = 0 ;
39008 PyObject * obj2 = 0 ;
39009 PyObject * obj3 = 0 ;
39010 char * kwnames[] = {
39011 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39012 };
39013
39014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39016 if (!SWIG_IsOK(res1)) {
39017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39018 }
39019 arg1 = reinterpret_cast< wxMenu * >(argp1);
39020 ecode2 = SWIG_AsVal_int(obj1, &val2);
39021 if (!SWIG_IsOK(ecode2)) {
39022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39023 }
39024 arg2 = static_cast< int >(val2);
39025 {
39026 arg3 = wxString_in_helper(obj2);
39027 if (arg3 == NULL) SWIG_fail;
39028 temp3 = true;
39029 }
39030 if (obj3) {
39031 {
39032 arg4 = wxString_in_helper(obj3);
39033 if (arg4 == NULL) SWIG_fail;
39034 temp4 = true;
39035 }
39036 }
39037 {
39038 PyThreadState* __tstate = wxPyBeginAllowThreads();
39039 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39040 wxPyEndAllowThreads(__tstate);
39041 if (PyErr_Occurred()) SWIG_fail;
39042 }
39043 {
39044 resultobj = wxPyMake_wxObject(result, (bool)0);
39045 }
39046 {
39047 if (temp3)
39048 delete arg3;
39049 }
39050 {
39051 if (temp4)
39052 delete arg4;
39053 }
39054 return resultobj;
39055 fail:
39056 {
39057 if (temp3)
39058 delete arg3;
39059 }
39060 {
39061 if (temp4)
39062 delete arg4;
39063 }
39064 return NULL;
39065 }
39066
39067
39068 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39069 PyObject *resultobj = 0;
39070 wxMenu *arg1 = (wxMenu *) 0 ;
39071 int arg2 ;
39072 wxString *arg3 = 0 ;
39073 wxMenu *arg4 = (wxMenu *) 0 ;
39074 wxString const &arg5_defvalue = wxPyEmptyString ;
39075 wxString *arg5 = (wxString *) &arg5_defvalue ;
39076 wxMenuItem *result = 0 ;
39077 void *argp1 = 0 ;
39078 int res1 = 0 ;
39079 int val2 ;
39080 int ecode2 = 0 ;
39081 bool temp3 = false ;
39082 void *argp4 = 0 ;
39083 int res4 = 0 ;
39084 bool temp5 = false ;
39085 PyObject * obj0 = 0 ;
39086 PyObject * obj1 = 0 ;
39087 PyObject * obj2 = 0 ;
39088 PyObject * obj3 = 0 ;
39089 PyObject * obj4 = 0 ;
39090 char * kwnames[] = {
39091 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39092 };
39093
39094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39096 if (!SWIG_IsOK(res1)) {
39097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39098 }
39099 arg1 = reinterpret_cast< wxMenu * >(argp1);
39100 ecode2 = SWIG_AsVal_int(obj1, &val2);
39101 if (!SWIG_IsOK(ecode2)) {
39102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39103 }
39104 arg2 = static_cast< int >(val2);
39105 {
39106 arg3 = wxString_in_helper(obj2);
39107 if (arg3 == NULL) SWIG_fail;
39108 temp3 = true;
39109 }
39110 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39111 if (!SWIG_IsOK(res4)) {
39112 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39113 }
39114 arg4 = reinterpret_cast< wxMenu * >(argp4);
39115 if (obj4) {
39116 {
39117 arg5 = wxString_in_helper(obj4);
39118 if (arg5 == NULL) SWIG_fail;
39119 temp5 = true;
39120 }
39121 }
39122 {
39123 PyThreadState* __tstate = wxPyBeginAllowThreads();
39124 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39125 wxPyEndAllowThreads(__tstate);
39126 if (PyErr_Occurred()) SWIG_fail;
39127 }
39128 {
39129 resultobj = wxPyMake_wxObject(result, (bool)0);
39130 }
39131 {
39132 if (temp3)
39133 delete arg3;
39134 }
39135 {
39136 if (temp5)
39137 delete arg5;
39138 }
39139 return resultobj;
39140 fail:
39141 {
39142 if (temp3)
39143 delete arg3;
39144 }
39145 {
39146 if (temp5)
39147 delete arg5;
39148 }
39149 return NULL;
39150 }
39151
39152
39153 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39154 PyObject *resultobj = 0;
39155 wxMenu *arg1 = (wxMenu *) 0 ;
39156 int arg2 ;
39157 wxMenuItem *result = 0 ;
39158 void *argp1 = 0 ;
39159 int res1 = 0 ;
39160 int val2 ;
39161 int ecode2 = 0 ;
39162 PyObject * obj0 = 0 ;
39163 PyObject * obj1 = 0 ;
39164 char * kwnames[] = {
39165 (char *) "self",(char *) "id", NULL
39166 };
39167
39168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39170 if (!SWIG_IsOK(res1)) {
39171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39172 }
39173 arg1 = reinterpret_cast< wxMenu * >(argp1);
39174 ecode2 = SWIG_AsVal_int(obj1, &val2);
39175 if (!SWIG_IsOK(ecode2)) {
39176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39177 }
39178 arg2 = static_cast< int >(val2);
39179 {
39180 PyThreadState* __tstate = wxPyBeginAllowThreads();
39181 result = (wxMenuItem *)(arg1)->Remove(arg2);
39182 wxPyEndAllowThreads(__tstate);
39183 if (PyErr_Occurred()) SWIG_fail;
39184 }
39185 {
39186 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39187 }
39188 return resultobj;
39189 fail:
39190 return NULL;
39191 }
39192
39193
39194 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39195 PyObject *resultobj = 0;
39196 wxMenu *arg1 = (wxMenu *) 0 ;
39197 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39198 wxMenuItem *result = 0 ;
39199 void *argp1 = 0 ;
39200 int res1 = 0 ;
39201 void *argp2 = 0 ;
39202 int res2 = 0 ;
39203 PyObject * obj0 = 0 ;
39204 PyObject * obj1 = 0 ;
39205 char * kwnames[] = {
39206 (char *) "self",(char *) "item", NULL
39207 };
39208
39209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39211 if (!SWIG_IsOK(res1)) {
39212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39213 }
39214 arg1 = reinterpret_cast< wxMenu * >(argp1);
39215 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39216 if (!SWIG_IsOK(res2)) {
39217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39218 }
39219 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39220 {
39221 PyThreadState* __tstate = wxPyBeginAllowThreads();
39222 result = (wxMenuItem *)(arg1)->Remove(arg2);
39223 wxPyEndAllowThreads(__tstate);
39224 if (PyErr_Occurred()) SWIG_fail;
39225 }
39226 {
39227 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39228 }
39229 return resultobj;
39230 fail:
39231 return NULL;
39232 }
39233
39234
39235 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39236 PyObject *resultobj = 0;
39237 wxMenu *arg1 = (wxMenu *) 0 ;
39238 int arg2 ;
39239 bool result;
39240 void *argp1 = 0 ;
39241 int res1 = 0 ;
39242 int val2 ;
39243 int ecode2 = 0 ;
39244 PyObject * obj0 = 0 ;
39245 PyObject * obj1 = 0 ;
39246 char * kwnames[] = {
39247 (char *) "self",(char *) "id", NULL
39248 };
39249
39250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39252 if (!SWIG_IsOK(res1)) {
39253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39254 }
39255 arg1 = reinterpret_cast< wxMenu * >(argp1);
39256 ecode2 = SWIG_AsVal_int(obj1, &val2);
39257 if (!SWIG_IsOK(ecode2)) {
39258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39259 }
39260 arg2 = static_cast< int >(val2);
39261 {
39262 PyThreadState* __tstate = wxPyBeginAllowThreads();
39263 result = (bool)(arg1)->Delete(arg2);
39264 wxPyEndAllowThreads(__tstate);
39265 if (PyErr_Occurred()) SWIG_fail;
39266 }
39267 {
39268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39269 }
39270 return resultobj;
39271 fail:
39272 return NULL;
39273 }
39274
39275
39276 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39277 PyObject *resultobj = 0;
39278 wxMenu *arg1 = (wxMenu *) 0 ;
39279 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39280 bool result;
39281 void *argp1 = 0 ;
39282 int res1 = 0 ;
39283 void *argp2 = 0 ;
39284 int res2 = 0 ;
39285 PyObject * obj0 = 0 ;
39286 PyObject * obj1 = 0 ;
39287 char * kwnames[] = {
39288 (char *) "self",(char *) "item", NULL
39289 };
39290
39291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39293 if (!SWIG_IsOK(res1)) {
39294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39295 }
39296 arg1 = reinterpret_cast< wxMenu * >(argp1);
39297 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39298 if (!SWIG_IsOK(res2)) {
39299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39300 }
39301 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39302 {
39303 PyThreadState* __tstate = wxPyBeginAllowThreads();
39304 result = (bool)(arg1)->Delete(arg2);
39305 wxPyEndAllowThreads(__tstate);
39306 if (PyErr_Occurred()) SWIG_fail;
39307 }
39308 {
39309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39310 }
39311 return resultobj;
39312 fail:
39313 return NULL;
39314 }
39315
39316
39317 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39318 PyObject *resultobj = 0;
39319 wxMenu *arg1 = (wxMenu *) 0 ;
39320 void *argp1 = 0 ;
39321 int res1 = 0 ;
39322 PyObject *swig_obj[1] ;
39323
39324 if (!args) SWIG_fail;
39325 swig_obj[0] = args;
39326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39327 if (!SWIG_IsOK(res1)) {
39328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39329 }
39330 arg1 = reinterpret_cast< wxMenu * >(argp1);
39331 {
39332 PyThreadState* __tstate = wxPyBeginAllowThreads();
39333 wxMenu_Destroy(arg1);
39334 wxPyEndAllowThreads(__tstate);
39335 if (PyErr_Occurred()) SWIG_fail;
39336 }
39337 resultobj = SWIG_Py_Void();
39338 return resultobj;
39339 fail:
39340 return NULL;
39341 }
39342
39343
39344 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39345 PyObject *resultobj = 0;
39346 wxMenu *arg1 = (wxMenu *) 0 ;
39347 int arg2 ;
39348 bool result;
39349 void *argp1 = 0 ;
39350 int res1 = 0 ;
39351 int val2 ;
39352 int ecode2 = 0 ;
39353 PyObject * obj0 = 0 ;
39354 PyObject * obj1 = 0 ;
39355 char * kwnames[] = {
39356 (char *) "self",(char *) "id", NULL
39357 };
39358
39359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39361 if (!SWIG_IsOK(res1)) {
39362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39363 }
39364 arg1 = reinterpret_cast< wxMenu * >(argp1);
39365 ecode2 = SWIG_AsVal_int(obj1, &val2);
39366 if (!SWIG_IsOK(ecode2)) {
39367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39368 }
39369 arg2 = static_cast< int >(val2);
39370 {
39371 PyThreadState* __tstate = wxPyBeginAllowThreads();
39372 result = (bool)(arg1)->Destroy(arg2);
39373 wxPyEndAllowThreads(__tstate);
39374 if (PyErr_Occurred()) SWIG_fail;
39375 }
39376 {
39377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39378 }
39379 return resultobj;
39380 fail:
39381 return NULL;
39382 }
39383
39384
39385 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39386 PyObject *resultobj = 0;
39387 wxMenu *arg1 = (wxMenu *) 0 ;
39388 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39389 bool result;
39390 void *argp1 = 0 ;
39391 int res1 = 0 ;
39392 void *argp2 = 0 ;
39393 int res2 = 0 ;
39394 PyObject * obj0 = 0 ;
39395 PyObject * obj1 = 0 ;
39396 char * kwnames[] = {
39397 (char *) "self",(char *) "item", NULL
39398 };
39399
39400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39402 if (!SWIG_IsOK(res1)) {
39403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39404 }
39405 arg1 = reinterpret_cast< wxMenu * >(argp1);
39406 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39407 if (!SWIG_IsOK(res2)) {
39408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39409 }
39410 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39411 {
39412 PyThreadState* __tstate = wxPyBeginAllowThreads();
39413 result = (bool)(arg1)->Destroy(arg2);
39414 wxPyEndAllowThreads(__tstate);
39415 if (PyErr_Occurred()) SWIG_fail;
39416 }
39417 {
39418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39419 }
39420 return resultobj;
39421 fail:
39422 return NULL;
39423 }
39424
39425
39426 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39427 PyObject *resultobj = 0;
39428 wxMenu *arg1 = (wxMenu *) 0 ;
39429 size_t result;
39430 void *argp1 = 0 ;
39431 int res1 = 0 ;
39432 PyObject *swig_obj[1] ;
39433
39434 if (!args) SWIG_fail;
39435 swig_obj[0] = args;
39436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39437 if (!SWIG_IsOK(res1)) {
39438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39439 }
39440 arg1 = reinterpret_cast< wxMenu * >(argp1);
39441 {
39442 PyThreadState* __tstate = wxPyBeginAllowThreads();
39443 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39444 wxPyEndAllowThreads(__tstate);
39445 if (PyErr_Occurred()) SWIG_fail;
39446 }
39447 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39448 return resultobj;
39449 fail:
39450 return NULL;
39451 }
39452
39453
39454 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39455 PyObject *resultobj = 0;
39456 wxMenu *arg1 = (wxMenu *) 0 ;
39457 PyObject *result = 0 ;
39458 void *argp1 = 0 ;
39459 int res1 = 0 ;
39460 PyObject *swig_obj[1] ;
39461
39462 if (!args) SWIG_fail;
39463 swig_obj[0] = args;
39464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39465 if (!SWIG_IsOK(res1)) {
39466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39467 }
39468 arg1 = reinterpret_cast< wxMenu * >(argp1);
39469 {
39470 PyThreadState* __tstate = wxPyBeginAllowThreads();
39471 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39472 wxPyEndAllowThreads(__tstate);
39473 if (PyErr_Occurred()) SWIG_fail;
39474 }
39475 resultobj = result;
39476 return resultobj;
39477 fail:
39478 return NULL;
39479 }
39480
39481
39482 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39483 PyObject *resultobj = 0;
39484 wxMenu *arg1 = (wxMenu *) 0 ;
39485 wxString *arg2 = 0 ;
39486 int result;
39487 void *argp1 = 0 ;
39488 int res1 = 0 ;
39489 bool temp2 = false ;
39490 PyObject * obj0 = 0 ;
39491 PyObject * obj1 = 0 ;
39492 char * kwnames[] = {
39493 (char *) "self",(char *) "item", NULL
39494 };
39495
39496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39498 if (!SWIG_IsOK(res1)) {
39499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39500 }
39501 arg1 = reinterpret_cast< wxMenu * >(argp1);
39502 {
39503 arg2 = wxString_in_helper(obj1);
39504 if (arg2 == NULL) SWIG_fail;
39505 temp2 = true;
39506 }
39507 {
39508 PyThreadState* __tstate = wxPyBeginAllowThreads();
39509 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39510 wxPyEndAllowThreads(__tstate);
39511 if (PyErr_Occurred()) SWIG_fail;
39512 }
39513 resultobj = SWIG_From_int(static_cast< int >(result));
39514 {
39515 if (temp2)
39516 delete arg2;
39517 }
39518 return resultobj;
39519 fail:
39520 {
39521 if (temp2)
39522 delete arg2;
39523 }
39524 return NULL;
39525 }
39526
39527
39528 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39529 PyObject *resultobj = 0;
39530 wxMenu *arg1 = (wxMenu *) 0 ;
39531 int arg2 ;
39532 wxMenuItem *result = 0 ;
39533 void *argp1 = 0 ;
39534 int res1 = 0 ;
39535 int val2 ;
39536 int ecode2 = 0 ;
39537 PyObject * obj0 = 0 ;
39538 PyObject * obj1 = 0 ;
39539 char * kwnames[] = {
39540 (char *) "self",(char *) "id", NULL
39541 };
39542
39543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39545 if (!SWIG_IsOK(res1)) {
39546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39547 }
39548 arg1 = reinterpret_cast< wxMenu * >(argp1);
39549 ecode2 = SWIG_AsVal_int(obj1, &val2);
39550 if (!SWIG_IsOK(ecode2)) {
39551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39552 }
39553 arg2 = static_cast< int >(val2);
39554 {
39555 PyThreadState* __tstate = wxPyBeginAllowThreads();
39556 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39557 wxPyEndAllowThreads(__tstate);
39558 if (PyErr_Occurred()) SWIG_fail;
39559 }
39560 {
39561 resultobj = wxPyMake_wxObject(result, (bool)0);
39562 }
39563 return resultobj;
39564 fail:
39565 return NULL;
39566 }
39567
39568
39569 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39570 PyObject *resultobj = 0;
39571 wxMenu *arg1 = (wxMenu *) 0 ;
39572 size_t arg2 ;
39573 wxMenuItem *result = 0 ;
39574 void *argp1 = 0 ;
39575 int res1 = 0 ;
39576 size_t val2 ;
39577 int ecode2 = 0 ;
39578 PyObject * obj0 = 0 ;
39579 PyObject * obj1 = 0 ;
39580 char * kwnames[] = {
39581 (char *) "self",(char *) "position", NULL
39582 };
39583
39584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39586 if (!SWIG_IsOK(res1)) {
39587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39588 }
39589 arg1 = reinterpret_cast< wxMenu * >(argp1);
39590 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39591 if (!SWIG_IsOK(ecode2)) {
39592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39593 }
39594 arg2 = static_cast< size_t >(val2);
39595 {
39596 PyThreadState* __tstate = wxPyBeginAllowThreads();
39597 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39598 wxPyEndAllowThreads(__tstate);
39599 if (PyErr_Occurred()) SWIG_fail;
39600 }
39601 {
39602 resultobj = wxPyMake_wxObject(result, (bool)0);
39603 }
39604 return resultobj;
39605 fail:
39606 return NULL;
39607 }
39608
39609
39610 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39611 PyObject *resultobj = 0;
39612 wxMenu *arg1 = (wxMenu *) 0 ;
39613 int arg2 ;
39614 bool arg3 ;
39615 void *argp1 = 0 ;
39616 int res1 = 0 ;
39617 int val2 ;
39618 int ecode2 = 0 ;
39619 bool val3 ;
39620 int ecode3 = 0 ;
39621 PyObject * obj0 = 0 ;
39622 PyObject * obj1 = 0 ;
39623 PyObject * obj2 = 0 ;
39624 char * kwnames[] = {
39625 (char *) "self",(char *) "id",(char *) "enable", NULL
39626 };
39627
39628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39630 if (!SWIG_IsOK(res1)) {
39631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39632 }
39633 arg1 = reinterpret_cast< wxMenu * >(argp1);
39634 ecode2 = SWIG_AsVal_int(obj1, &val2);
39635 if (!SWIG_IsOK(ecode2)) {
39636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39637 }
39638 arg2 = static_cast< int >(val2);
39639 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39640 if (!SWIG_IsOK(ecode3)) {
39641 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39642 }
39643 arg3 = static_cast< bool >(val3);
39644 {
39645 PyThreadState* __tstate = wxPyBeginAllowThreads();
39646 (arg1)->Enable(arg2,arg3);
39647 wxPyEndAllowThreads(__tstate);
39648 if (PyErr_Occurred()) SWIG_fail;
39649 }
39650 resultobj = SWIG_Py_Void();
39651 return resultobj;
39652 fail:
39653 return NULL;
39654 }
39655
39656
39657 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39658 PyObject *resultobj = 0;
39659 wxMenu *arg1 = (wxMenu *) 0 ;
39660 int arg2 ;
39661 bool result;
39662 void *argp1 = 0 ;
39663 int res1 = 0 ;
39664 int val2 ;
39665 int ecode2 = 0 ;
39666 PyObject * obj0 = 0 ;
39667 PyObject * obj1 = 0 ;
39668 char * kwnames[] = {
39669 (char *) "self",(char *) "id", NULL
39670 };
39671
39672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39674 if (!SWIG_IsOK(res1)) {
39675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39676 }
39677 arg1 = reinterpret_cast< wxMenu * >(argp1);
39678 ecode2 = SWIG_AsVal_int(obj1, &val2);
39679 if (!SWIG_IsOK(ecode2)) {
39680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39681 }
39682 arg2 = static_cast< int >(val2);
39683 {
39684 PyThreadState* __tstate = wxPyBeginAllowThreads();
39685 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39686 wxPyEndAllowThreads(__tstate);
39687 if (PyErr_Occurred()) SWIG_fail;
39688 }
39689 {
39690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39691 }
39692 return resultobj;
39693 fail:
39694 return NULL;
39695 }
39696
39697
39698 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39699 PyObject *resultobj = 0;
39700 wxMenu *arg1 = (wxMenu *) 0 ;
39701 int arg2 ;
39702 bool arg3 ;
39703 void *argp1 = 0 ;
39704 int res1 = 0 ;
39705 int val2 ;
39706 int ecode2 = 0 ;
39707 bool val3 ;
39708 int ecode3 = 0 ;
39709 PyObject * obj0 = 0 ;
39710 PyObject * obj1 = 0 ;
39711 PyObject * obj2 = 0 ;
39712 char * kwnames[] = {
39713 (char *) "self",(char *) "id",(char *) "check", NULL
39714 };
39715
39716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39718 if (!SWIG_IsOK(res1)) {
39719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
39720 }
39721 arg1 = reinterpret_cast< wxMenu * >(argp1);
39722 ecode2 = SWIG_AsVal_int(obj1, &val2);
39723 if (!SWIG_IsOK(ecode2)) {
39724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
39725 }
39726 arg2 = static_cast< int >(val2);
39727 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39728 if (!SWIG_IsOK(ecode3)) {
39729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
39730 }
39731 arg3 = static_cast< bool >(val3);
39732 {
39733 PyThreadState* __tstate = wxPyBeginAllowThreads();
39734 (arg1)->Check(arg2,arg3);
39735 wxPyEndAllowThreads(__tstate);
39736 if (PyErr_Occurred()) SWIG_fail;
39737 }
39738 resultobj = SWIG_Py_Void();
39739 return resultobj;
39740 fail:
39741 return NULL;
39742 }
39743
39744
39745 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39746 PyObject *resultobj = 0;
39747 wxMenu *arg1 = (wxMenu *) 0 ;
39748 int arg2 ;
39749 bool result;
39750 void *argp1 = 0 ;
39751 int res1 = 0 ;
39752 int val2 ;
39753 int ecode2 = 0 ;
39754 PyObject * obj0 = 0 ;
39755 PyObject * obj1 = 0 ;
39756 char * kwnames[] = {
39757 (char *) "self",(char *) "id", NULL
39758 };
39759
39760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
39761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39762 if (!SWIG_IsOK(res1)) {
39763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
39764 }
39765 arg1 = reinterpret_cast< wxMenu * >(argp1);
39766 ecode2 = SWIG_AsVal_int(obj1, &val2);
39767 if (!SWIG_IsOK(ecode2)) {
39768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
39769 }
39770 arg2 = static_cast< int >(val2);
39771 {
39772 PyThreadState* __tstate = wxPyBeginAllowThreads();
39773 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
39774 wxPyEndAllowThreads(__tstate);
39775 if (PyErr_Occurred()) SWIG_fail;
39776 }
39777 {
39778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39779 }
39780 return resultobj;
39781 fail:
39782 return NULL;
39783 }
39784
39785
39786 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39787 PyObject *resultobj = 0;
39788 wxMenu *arg1 = (wxMenu *) 0 ;
39789 int arg2 ;
39790 wxString *arg3 = 0 ;
39791 void *argp1 = 0 ;
39792 int res1 = 0 ;
39793 int val2 ;
39794 int ecode2 = 0 ;
39795 bool temp3 = false ;
39796 PyObject * obj0 = 0 ;
39797 PyObject * obj1 = 0 ;
39798 PyObject * obj2 = 0 ;
39799 char * kwnames[] = {
39800 (char *) "self",(char *) "id",(char *) "label", NULL
39801 };
39802
39803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39805 if (!SWIG_IsOK(res1)) {
39806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
39807 }
39808 arg1 = reinterpret_cast< wxMenu * >(argp1);
39809 ecode2 = SWIG_AsVal_int(obj1, &val2);
39810 if (!SWIG_IsOK(ecode2)) {
39811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
39812 }
39813 arg2 = static_cast< int >(val2);
39814 {
39815 arg3 = wxString_in_helper(obj2);
39816 if (arg3 == NULL) SWIG_fail;
39817 temp3 = true;
39818 }
39819 {
39820 PyThreadState* __tstate = wxPyBeginAllowThreads();
39821 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
39822 wxPyEndAllowThreads(__tstate);
39823 if (PyErr_Occurred()) SWIG_fail;
39824 }
39825 resultobj = SWIG_Py_Void();
39826 {
39827 if (temp3)
39828 delete arg3;
39829 }
39830 return resultobj;
39831 fail:
39832 {
39833 if (temp3)
39834 delete arg3;
39835 }
39836 return NULL;
39837 }
39838
39839
39840 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39841 PyObject *resultobj = 0;
39842 wxMenu *arg1 = (wxMenu *) 0 ;
39843 int arg2 ;
39844 wxString result;
39845 void *argp1 = 0 ;
39846 int res1 = 0 ;
39847 int val2 ;
39848 int ecode2 = 0 ;
39849 PyObject * obj0 = 0 ;
39850 PyObject * obj1 = 0 ;
39851 char * kwnames[] = {
39852 (char *) "self",(char *) "id", NULL
39853 };
39854
39855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39857 if (!SWIG_IsOK(res1)) {
39858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
39859 }
39860 arg1 = reinterpret_cast< wxMenu * >(argp1);
39861 ecode2 = SWIG_AsVal_int(obj1, &val2);
39862 if (!SWIG_IsOK(ecode2)) {
39863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
39864 }
39865 arg2 = static_cast< int >(val2);
39866 {
39867 PyThreadState* __tstate = wxPyBeginAllowThreads();
39868 result = ((wxMenu const *)arg1)->GetLabel(arg2);
39869 wxPyEndAllowThreads(__tstate);
39870 if (PyErr_Occurred()) SWIG_fail;
39871 }
39872 {
39873 #if wxUSE_UNICODE
39874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39875 #else
39876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39877 #endif
39878 }
39879 return resultobj;
39880 fail:
39881 return NULL;
39882 }
39883
39884
39885 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39886 PyObject *resultobj = 0;
39887 wxMenu *arg1 = (wxMenu *) 0 ;
39888 int arg2 ;
39889 wxString *arg3 = 0 ;
39890 void *argp1 = 0 ;
39891 int res1 = 0 ;
39892 int val2 ;
39893 int ecode2 = 0 ;
39894 bool temp3 = false ;
39895 PyObject * obj0 = 0 ;
39896 PyObject * obj1 = 0 ;
39897 PyObject * obj2 = 0 ;
39898 char * kwnames[] = {
39899 (char *) "self",(char *) "id",(char *) "helpString", NULL
39900 };
39901
39902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39904 if (!SWIG_IsOK(res1)) {
39905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
39906 }
39907 arg1 = reinterpret_cast< wxMenu * >(argp1);
39908 ecode2 = SWIG_AsVal_int(obj1, &val2);
39909 if (!SWIG_IsOK(ecode2)) {
39910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
39911 }
39912 arg2 = static_cast< int >(val2);
39913 {
39914 arg3 = wxString_in_helper(obj2);
39915 if (arg3 == NULL) SWIG_fail;
39916 temp3 = true;
39917 }
39918 {
39919 PyThreadState* __tstate = wxPyBeginAllowThreads();
39920 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
39921 wxPyEndAllowThreads(__tstate);
39922 if (PyErr_Occurred()) SWIG_fail;
39923 }
39924 resultobj = SWIG_Py_Void();
39925 {
39926 if (temp3)
39927 delete arg3;
39928 }
39929 return resultobj;
39930 fail:
39931 {
39932 if (temp3)
39933 delete arg3;
39934 }
39935 return NULL;
39936 }
39937
39938
39939 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39940 PyObject *resultobj = 0;
39941 wxMenu *arg1 = (wxMenu *) 0 ;
39942 int arg2 ;
39943 wxString result;
39944 void *argp1 = 0 ;
39945 int res1 = 0 ;
39946 int val2 ;
39947 int ecode2 = 0 ;
39948 PyObject * obj0 = 0 ;
39949 PyObject * obj1 = 0 ;
39950 char * kwnames[] = {
39951 (char *) "self",(char *) "id", NULL
39952 };
39953
39954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
39955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39956 if (!SWIG_IsOK(res1)) {
39957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
39958 }
39959 arg1 = reinterpret_cast< wxMenu * >(argp1);
39960 ecode2 = SWIG_AsVal_int(obj1, &val2);
39961 if (!SWIG_IsOK(ecode2)) {
39962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
39963 }
39964 arg2 = static_cast< int >(val2);
39965 {
39966 PyThreadState* __tstate = wxPyBeginAllowThreads();
39967 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
39968 wxPyEndAllowThreads(__tstate);
39969 if (PyErr_Occurred()) SWIG_fail;
39970 }
39971 {
39972 #if wxUSE_UNICODE
39973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39974 #else
39975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39976 #endif
39977 }
39978 return resultobj;
39979 fail:
39980 return NULL;
39981 }
39982
39983
39984 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39985 PyObject *resultobj = 0;
39986 wxMenu *arg1 = (wxMenu *) 0 ;
39987 wxString *arg2 = 0 ;
39988 void *argp1 = 0 ;
39989 int res1 = 0 ;
39990 bool temp2 = false ;
39991 PyObject * obj0 = 0 ;
39992 PyObject * obj1 = 0 ;
39993 char * kwnames[] = {
39994 (char *) "self",(char *) "title", NULL
39995 };
39996
39997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
39998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39999 if (!SWIG_IsOK(res1)) {
40000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40001 }
40002 arg1 = reinterpret_cast< wxMenu * >(argp1);
40003 {
40004 arg2 = wxString_in_helper(obj1);
40005 if (arg2 == NULL) SWIG_fail;
40006 temp2 = true;
40007 }
40008 {
40009 PyThreadState* __tstate = wxPyBeginAllowThreads();
40010 (arg1)->SetTitle((wxString const &)*arg2);
40011 wxPyEndAllowThreads(__tstate);
40012 if (PyErr_Occurred()) SWIG_fail;
40013 }
40014 resultobj = SWIG_Py_Void();
40015 {
40016 if (temp2)
40017 delete arg2;
40018 }
40019 return resultobj;
40020 fail:
40021 {
40022 if (temp2)
40023 delete arg2;
40024 }
40025 return NULL;
40026 }
40027
40028
40029 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40030 PyObject *resultobj = 0;
40031 wxMenu *arg1 = (wxMenu *) 0 ;
40032 wxString result;
40033 void *argp1 = 0 ;
40034 int res1 = 0 ;
40035 PyObject *swig_obj[1] ;
40036
40037 if (!args) SWIG_fail;
40038 swig_obj[0] = args;
40039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40040 if (!SWIG_IsOK(res1)) {
40041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40042 }
40043 arg1 = reinterpret_cast< wxMenu * >(argp1);
40044 {
40045 PyThreadState* __tstate = wxPyBeginAllowThreads();
40046 result = ((wxMenu const *)arg1)->GetTitle();
40047 wxPyEndAllowThreads(__tstate);
40048 if (PyErr_Occurred()) SWIG_fail;
40049 }
40050 {
40051 #if wxUSE_UNICODE
40052 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40053 #else
40054 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40055 #endif
40056 }
40057 return resultobj;
40058 fail:
40059 return NULL;
40060 }
40061
40062
40063 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40064 PyObject *resultobj = 0;
40065 wxMenu *arg1 = (wxMenu *) 0 ;
40066 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40067 void *argp1 = 0 ;
40068 int res1 = 0 ;
40069 void *argp2 = 0 ;
40070 int res2 = 0 ;
40071 PyObject * obj0 = 0 ;
40072 PyObject * obj1 = 0 ;
40073 char * kwnames[] = {
40074 (char *) "self",(char *) "handler", NULL
40075 };
40076
40077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40079 if (!SWIG_IsOK(res1)) {
40080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40081 }
40082 arg1 = reinterpret_cast< wxMenu * >(argp1);
40083 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40084 if (!SWIG_IsOK(res2)) {
40085 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40086 }
40087 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40088 {
40089 PyThreadState* __tstate = wxPyBeginAllowThreads();
40090 (arg1)->SetEventHandler(arg2);
40091 wxPyEndAllowThreads(__tstate);
40092 if (PyErr_Occurred()) SWIG_fail;
40093 }
40094 resultobj = SWIG_Py_Void();
40095 return resultobj;
40096 fail:
40097 return NULL;
40098 }
40099
40100
40101 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40102 PyObject *resultobj = 0;
40103 wxMenu *arg1 = (wxMenu *) 0 ;
40104 wxEvtHandler *result = 0 ;
40105 void *argp1 = 0 ;
40106 int res1 = 0 ;
40107 PyObject *swig_obj[1] ;
40108
40109 if (!args) SWIG_fail;
40110 swig_obj[0] = args;
40111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40112 if (!SWIG_IsOK(res1)) {
40113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40114 }
40115 arg1 = reinterpret_cast< wxMenu * >(argp1);
40116 {
40117 PyThreadState* __tstate = wxPyBeginAllowThreads();
40118 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40119 wxPyEndAllowThreads(__tstate);
40120 if (PyErr_Occurred()) SWIG_fail;
40121 }
40122 {
40123 resultobj = wxPyMake_wxObject(result, 0);
40124 }
40125 return resultobj;
40126 fail:
40127 return NULL;
40128 }
40129
40130
40131 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40132 PyObject *resultobj = 0;
40133 wxMenu *arg1 = (wxMenu *) 0 ;
40134 wxWindow *arg2 = (wxWindow *) 0 ;
40135 void *argp1 = 0 ;
40136 int res1 = 0 ;
40137 void *argp2 = 0 ;
40138 int res2 = 0 ;
40139 PyObject * obj0 = 0 ;
40140 PyObject * obj1 = 0 ;
40141 char * kwnames[] = {
40142 (char *) "self",(char *) "win", NULL
40143 };
40144
40145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40147 if (!SWIG_IsOK(res1)) {
40148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40149 }
40150 arg1 = reinterpret_cast< wxMenu * >(argp1);
40151 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40152 if (!SWIG_IsOK(res2)) {
40153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40154 }
40155 arg2 = reinterpret_cast< wxWindow * >(argp2);
40156 {
40157 PyThreadState* __tstate = wxPyBeginAllowThreads();
40158 (arg1)->SetInvokingWindow(arg2);
40159 wxPyEndAllowThreads(__tstate);
40160 if (PyErr_Occurred()) SWIG_fail;
40161 }
40162 resultobj = SWIG_Py_Void();
40163 return resultobj;
40164 fail:
40165 return NULL;
40166 }
40167
40168
40169 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40170 PyObject *resultobj = 0;
40171 wxMenu *arg1 = (wxMenu *) 0 ;
40172 wxWindow *result = 0 ;
40173 void *argp1 = 0 ;
40174 int res1 = 0 ;
40175 PyObject *swig_obj[1] ;
40176
40177 if (!args) SWIG_fail;
40178 swig_obj[0] = args;
40179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40180 if (!SWIG_IsOK(res1)) {
40181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40182 }
40183 arg1 = reinterpret_cast< wxMenu * >(argp1);
40184 {
40185 PyThreadState* __tstate = wxPyBeginAllowThreads();
40186 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40187 wxPyEndAllowThreads(__tstate);
40188 if (PyErr_Occurred()) SWIG_fail;
40189 }
40190 {
40191 resultobj = wxPyMake_wxObject(result, 0);
40192 }
40193 return resultobj;
40194 fail:
40195 return NULL;
40196 }
40197
40198
40199 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40200 PyObject *resultobj = 0;
40201 wxMenu *arg1 = (wxMenu *) 0 ;
40202 long result;
40203 void *argp1 = 0 ;
40204 int res1 = 0 ;
40205 PyObject *swig_obj[1] ;
40206
40207 if (!args) SWIG_fail;
40208 swig_obj[0] = args;
40209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40210 if (!SWIG_IsOK(res1)) {
40211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40212 }
40213 arg1 = reinterpret_cast< wxMenu * >(argp1);
40214 {
40215 PyThreadState* __tstate = wxPyBeginAllowThreads();
40216 result = (long)((wxMenu const *)arg1)->GetStyle();
40217 wxPyEndAllowThreads(__tstate);
40218 if (PyErr_Occurred()) SWIG_fail;
40219 }
40220 resultobj = SWIG_From_long(static_cast< long >(result));
40221 return resultobj;
40222 fail:
40223 return NULL;
40224 }
40225
40226
40227 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40228 PyObject *resultobj = 0;
40229 wxMenu *arg1 = (wxMenu *) 0 ;
40230 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40231 void *argp1 = 0 ;
40232 int res1 = 0 ;
40233 void *argp2 = 0 ;
40234 int res2 = 0 ;
40235 PyObject * obj0 = 0 ;
40236 PyObject * obj1 = 0 ;
40237 char * kwnames[] = {
40238 (char *) "self",(char *) "source", NULL
40239 };
40240
40241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40243 if (!SWIG_IsOK(res1)) {
40244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40245 }
40246 arg1 = reinterpret_cast< wxMenu * >(argp1);
40247 if (obj1) {
40248 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40249 if (!SWIG_IsOK(res2)) {
40250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40251 }
40252 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40253 }
40254 {
40255 PyThreadState* __tstate = wxPyBeginAllowThreads();
40256 (arg1)->UpdateUI(arg2);
40257 wxPyEndAllowThreads(__tstate);
40258 if (PyErr_Occurred()) SWIG_fail;
40259 }
40260 resultobj = SWIG_Py_Void();
40261 return resultobj;
40262 fail:
40263 return NULL;
40264 }
40265
40266
40267 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40268 PyObject *resultobj = 0;
40269 wxMenu *arg1 = (wxMenu *) 0 ;
40270 wxMenuBar *result = 0 ;
40271 void *argp1 = 0 ;
40272 int res1 = 0 ;
40273 PyObject *swig_obj[1] ;
40274
40275 if (!args) SWIG_fail;
40276 swig_obj[0] = args;
40277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40278 if (!SWIG_IsOK(res1)) {
40279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40280 }
40281 arg1 = reinterpret_cast< wxMenu * >(argp1);
40282 {
40283 PyThreadState* __tstate = wxPyBeginAllowThreads();
40284 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40285 wxPyEndAllowThreads(__tstate);
40286 if (PyErr_Occurred()) SWIG_fail;
40287 }
40288 {
40289 resultobj = wxPyMake_wxObject(result, (bool)0);
40290 }
40291 return resultobj;
40292 fail:
40293 return NULL;
40294 }
40295
40296
40297 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40298 PyObject *resultobj = 0;
40299 wxMenu *arg1 = (wxMenu *) 0 ;
40300 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40301 void *argp1 = 0 ;
40302 int res1 = 0 ;
40303 void *argp2 = 0 ;
40304 int res2 = 0 ;
40305 PyObject * obj0 = 0 ;
40306 PyObject * obj1 = 0 ;
40307 char * kwnames[] = {
40308 (char *) "self",(char *) "menubar", NULL
40309 };
40310
40311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40313 if (!SWIG_IsOK(res1)) {
40314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40315 }
40316 arg1 = reinterpret_cast< wxMenu * >(argp1);
40317 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40318 if (!SWIG_IsOK(res2)) {
40319 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40320 }
40321 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40322 {
40323 PyThreadState* __tstate = wxPyBeginAllowThreads();
40324 (arg1)->Attach(arg2);
40325 wxPyEndAllowThreads(__tstate);
40326 if (PyErr_Occurred()) SWIG_fail;
40327 }
40328 resultobj = SWIG_Py_Void();
40329 return resultobj;
40330 fail:
40331 return NULL;
40332 }
40333
40334
40335 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40336 PyObject *resultobj = 0;
40337 wxMenu *arg1 = (wxMenu *) 0 ;
40338 void *argp1 = 0 ;
40339 int res1 = 0 ;
40340 PyObject *swig_obj[1] ;
40341
40342 if (!args) SWIG_fail;
40343 swig_obj[0] = args;
40344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40345 if (!SWIG_IsOK(res1)) {
40346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40347 }
40348 arg1 = reinterpret_cast< wxMenu * >(argp1);
40349 {
40350 PyThreadState* __tstate = wxPyBeginAllowThreads();
40351 (arg1)->Detach();
40352 wxPyEndAllowThreads(__tstate);
40353 if (PyErr_Occurred()) SWIG_fail;
40354 }
40355 resultobj = SWIG_Py_Void();
40356 return resultobj;
40357 fail:
40358 return NULL;
40359 }
40360
40361
40362 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40363 PyObject *resultobj = 0;
40364 wxMenu *arg1 = (wxMenu *) 0 ;
40365 bool result;
40366 void *argp1 = 0 ;
40367 int res1 = 0 ;
40368 PyObject *swig_obj[1] ;
40369
40370 if (!args) SWIG_fail;
40371 swig_obj[0] = args;
40372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40373 if (!SWIG_IsOK(res1)) {
40374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40375 }
40376 arg1 = reinterpret_cast< wxMenu * >(argp1);
40377 {
40378 PyThreadState* __tstate = wxPyBeginAllowThreads();
40379 result = (bool)((wxMenu const *)arg1)->IsAttached();
40380 wxPyEndAllowThreads(__tstate);
40381 if (PyErr_Occurred()) SWIG_fail;
40382 }
40383 {
40384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40385 }
40386 return resultobj;
40387 fail:
40388 return NULL;
40389 }
40390
40391
40392 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40393 PyObject *resultobj = 0;
40394 wxMenu *arg1 = (wxMenu *) 0 ;
40395 wxMenu *arg2 = (wxMenu *) 0 ;
40396 void *argp1 = 0 ;
40397 int res1 = 0 ;
40398 void *argp2 = 0 ;
40399 int res2 = 0 ;
40400 PyObject * obj0 = 0 ;
40401 PyObject * obj1 = 0 ;
40402 char * kwnames[] = {
40403 (char *) "self",(char *) "parent", NULL
40404 };
40405
40406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40408 if (!SWIG_IsOK(res1)) {
40409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40410 }
40411 arg1 = reinterpret_cast< wxMenu * >(argp1);
40412 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40413 if (!SWIG_IsOK(res2)) {
40414 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40415 }
40416 arg2 = reinterpret_cast< wxMenu * >(argp2);
40417 {
40418 PyThreadState* __tstate = wxPyBeginAllowThreads();
40419 (arg1)->SetParent(arg2);
40420 wxPyEndAllowThreads(__tstate);
40421 if (PyErr_Occurred()) SWIG_fail;
40422 }
40423 resultobj = SWIG_Py_Void();
40424 return resultobj;
40425 fail:
40426 return NULL;
40427 }
40428
40429
40430 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40431 PyObject *resultobj = 0;
40432 wxMenu *arg1 = (wxMenu *) 0 ;
40433 wxMenu *result = 0 ;
40434 void *argp1 = 0 ;
40435 int res1 = 0 ;
40436 PyObject *swig_obj[1] ;
40437
40438 if (!args) SWIG_fail;
40439 swig_obj[0] = args;
40440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40441 if (!SWIG_IsOK(res1)) {
40442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40443 }
40444 arg1 = reinterpret_cast< wxMenu * >(argp1);
40445 {
40446 PyThreadState* __tstate = wxPyBeginAllowThreads();
40447 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40448 wxPyEndAllowThreads(__tstate);
40449 if (PyErr_Occurred()) SWIG_fail;
40450 }
40451 {
40452 resultobj = wxPyMake_wxObject(result, 0);
40453 }
40454 return resultobj;
40455 fail:
40456 return NULL;
40457 }
40458
40459
40460 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40461 PyObject *obj;
40462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40463 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40464 return SWIG_Py_Void();
40465 }
40466
40467 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40468 return SWIG_Python_InitShadowInstance(args);
40469 }
40470
40471 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40472 PyObject *resultobj = 0;
40473 long arg1 = (long) 0 ;
40474 wxMenuBar *result = 0 ;
40475 long val1 ;
40476 int ecode1 = 0 ;
40477 PyObject * obj0 = 0 ;
40478 char * kwnames[] = {
40479 (char *) "style", NULL
40480 };
40481
40482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40483 if (obj0) {
40484 ecode1 = SWIG_AsVal_long(obj0, &val1);
40485 if (!SWIG_IsOK(ecode1)) {
40486 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40487 }
40488 arg1 = static_cast< long >(val1);
40489 }
40490 {
40491 if (!wxPyCheckForApp()) SWIG_fail;
40492 PyThreadState* __tstate = wxPyBeginAllowThreads();
40493 result = (wxMenuBar *)new wxMenuBar(arg1);
40494 wxPyEndAllowThreads(__tstate);
40495 if (PyErr_Occurred()) SWIG_fail;
40496 }
40497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40498 return resultobj;
40499 fail:
40500 return NULL;
40501 }
40502
40503
40504 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40505 PyObject *resultobj = 0;
40506 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40507 wxMenu *arg2 = (wxMenu *) 0 ;
40508 wxString *arg3 = 0 ;
40509 bool result;
40510 void *argp1 = 0 ;
40511 int res1 = 0 ;
40512 void *argp2 = 0 ;
40513 int res2 = 0 ;
40514 bool temp3 = false ;
40515 PyObject * obj0 = 0 ;
40516 PyObject * obj1 = 0 ;
40517 PyObject * obj2 = 0 ;
40518 char * kwnames[] = {
40519 (char *) "self",(char *) "menu",(char *) "title", NULL
40520 };
40521
40522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40524 if (!SWIG_IsOK(res1)) {
40525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40526 }
40527 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40528 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40529 if (!SWIG_IsOK(res2)) {
40530 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40531 }
40532 arg2 = reinterpret_cast< wxMenu * >(argp2);
40533 {
40534 arg3 = wxString_in_helper(obj2);
40535 if (arg3 == NULL) SWIG_fail;
40536 temp3 = true;
40537 }
40538 {
40539 PyThreadState* __tstate = wxPyBeginAllowThreads();
40540 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40541 wxPyEndAllowThreads(__tstate);
40542 if (PyErr_Occurred()) SWIG_fail;
40543 }
40544 {
40545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40546 }
40547 {
40548 if (temp3)
40549 delete arg3;
40550 }
40551 return resultobj;
40552 fail:
40553 {
40554 if (temp3)
40555 delete arg3;
40556 }
40557 return NULL;
40558 }
40559
40560
40561 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40562 PyObject *resultobj = 0;
40563 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40564 size_t arg2 ;
40565 wxMenu *arg3 = (wxMenu *) 0 ;
40566 wxString *arg4 = 0 ;
40567 bool result;
40568 void *argp1 = 0 ;
40569 int res1 = 0 ;
40570 size_t val2 ;
40571 int ecode2 = 0 ;
40572 void *argp3 = 0 ;
40573 int res3 = 0 ;
40574 bool temp4 = false ;
40575 PyObject * obj0 = 0 ;
40576 PyObject * obj1 = 0 ;
40577 PyObject * obj2 = 0 ;
40578 PyObject * obj3 = 0 ;
40579 char * kwnames[] = {
40580 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40581 };
40582
40583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40585 if (!SWIG_IsOK(res1)) {
40586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40587 }
40588 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40589 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40590 if (!SWIG_IsOK(ecode2)) {
40591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40592 }
40593 arg2 = static_cast< size_t >(val2);
40594 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40595 if (!SWIG_IsOK(res3)) {
40596 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40597 }
40598 arg3 = reinterpret_cast< wxMenu * >(argp3);
40599 {
40600 arg4 = wxString_in_helper(obj3);
40601 if (arg4 == NULL) SWIG_fail;
40602 temp4 = true;
40603 }
40604 {
40605 PyThreadState* __tstate = wxPyBeginAllowThreads();
40606 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40607 wxPyEndAllowThreads(__tstate);
40608 if (PyErr_Occurred()) SWIG_fail;
40609 }
40610 {
40611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40612 }
40613 {
40614 if (temp4)
40615 delete arg4;
40616 }
40617 return resultobj;
40618 fail:
40619 {
40620 if (temp4)
40621 delete arg4;
40622 }
40623 return NULL;
40624 }
40625
40626
40627 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40628 PyObject *resultobj = 0;
40629 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40630 size_t result;
40631 void *argp1 = 0 ;
40632 int res1 = 0 ;
40633 PyObject *swig_obj[1] ;
40634
40635 if (!args) SWIG_fail;
40636 swig_obj[0] = args;
40637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40638 if (!SWIG_IsOK(res1)) {
40639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40640 }
40641 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40642 {
40643 PyThreadState* __tstate = wxPyBeginAllowThreads();
40644 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40645 wxPyEndAllowThreads(__tstate);
40646 if (PyErr_Occurred()) SWIG_fail;
40647 }
40648 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40649 return resultobj;
40650 fail:
40651 return NULL;
40652 }
40653
40654
40655 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40656 PyObject *resultobj = 0;
40657 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40658 size_t arg2 ;
40659 wxMenu *result = 0 ;
40660 void *argp1 = 0 ;
40661 int res1 = 0 ;
40662 size_t val2 ;
40663 int ecode2 = 0 ;
40664 PyObject * obj0 = 0 ;
40665 PyObject * obj1 = 0 ;
40666 char * kwnames[] = {
40667 (char *) "self",(char *) "pos", NULL
40668 };
40669
40670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40672 if (!SWIG_IsOK(res1)) {
40673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40674 }
40675 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40676 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40677 if (!SWIG_IsOK(ecode2)) {
40678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40679 }
40680 arg2 = static_cast< size_t >(val2);
40681 {
40682 PyThreadState* __tstate = wxPyBeginAllowThreads();
40683 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40684 wxPyEndAllowThreads(__tstate);
40685 if (PyErr_Occurred()) SWIG_fail;
40686 }
40687 {
40688 resultobj = wxPyMake_wxObject(result, 0);
40689 }
40690 return resultobj;
40691 fail:
40692 return NULL;
40693 }
40694
40695
40696 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40697 PyObject *resultobj = 0;
40698 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40699 size_t arg2 ;
40700 wxMenu *arg3 = (wxMenu *) 0 ;
40701 wxString *arg4 = 0 ;
40702 wxMenu *result = 0 ;
40703 void *argp1 = 0 ;
40704 int res1 = 0 ;
40705 size_t val2 ;
40706 int ecode2 = 0 ;
40707 void *argp3 = 0 ;
40708 int res3 = 0 ;
40709 bool temp4 = false ;
40710 PyObject * obj0 = 0 ;
40711 PyObject * obj1 = 0 ;
40712 PyObject * obj2 = 0 ;
40713 PyObject * obj3 = 0 ;
40714 char * kwnames[] = {
40715 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40716 };
40717
40718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40720 if (!SWIG_IsOK(res1)) {
40721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40722 }
40723 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40724 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40725 if (!SWIG_IsOK(ecode2)) {
40726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40727 }
40728 arg2 = static_cast< size_t >(val2);
40729 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40730 if (!SWIG_IsOK(res3)) {
40731 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
40732 }
40733 arg3 = reinterpret_cast< wxMenu * >(argp3);
40734 {
40735 arg4 = wxString_in_helper(obj3);
40736 if (arg4 == NULL) SWIG_fail;
40737 temp4 = true;
40738 }
40739 {
40740 PyThreadState* __tstate = wxPyBeginAllowThreads();
40741 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
40742 wxPyEndAllowThreads(__tstate);
40743 if (PyErr_Occurred()) SWIG_fail;
40744 }
40745 {
40746 resultobj = wxPyMake_wxObject(result, 0);
40747 }
40748 {
40749 if (temp4)
40750 delete arg4;
40751 }
40752 return resultobj;
40753 fail:
40754 {
40755 if (temp4)
40756 delete arg4;
40757 }
40758 return NULL;
40759 }
40760
40761
40762 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40763 PyObject *resultobj = 0;
40764 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40765 size_t arg2 ;
40766 wxMenu *result = 0 ;
40767 void *argp1 = 0 ;
40768 int res1 = 0 ;
40769 size_t val2 ;
40770 int ecode2 = 0 ;
40771 PyObject * obj0 = 0 ;
40772 PyObject * obj1 = 0 ;
40773 char * kwnames[] = {
40774 (char *) "self",(char *) "pos", NULL
40775 };
40776
40777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40779 if (!SWIG_IsOK(res1)) {
40780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40781 }
40782 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40783 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40784 if (!SWIG_IsOK(ecode2)) {
40785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
40786 }
40787 arg2 = static_cast< size_t >(val2);
40788 {
40789 PyThreadState* __tstate = wxPyBeginAllowThreads();
40790 result = (wxMenu *)(arg1)->Remove(arg2);
40791 wxPyEndAllowThreads(__tstate);
40792 if (PyErr_Occurred()) SWIG_fail;
40793 }
40794 {
40795 resultobj = wxPyMake_wxObject(result, 0);
40796 }
40797 return resultobj;
40798 fail:
40799 return NULL;
40800 }
40801
40802
40803 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40804 PyObject *resultobj = 0;
40805 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40806 size_t arg2 ;
40807 bool arg3 ;
40808 void *argp1 = 0 ;
40809 int res1 = 0 ;
40810 size_t val2 ;
40811 int ecode2 = 0 ;
40812 bool val3 ;
40813 int ecode3 = 0 ;
40814 PyObject * obj0 = 0 ;
40815 PyObject * obj1 = 0 ;
40816 PyObject * obj2 = 0 ;
40817 char * kwnames[] = {
40818 (char *) "self",(char *) "pos",(char *) "enable", NULL
40819 };
40820
40821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40823 if (!SWIG_IsOK(res1)) {
40824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40825 }
40826 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40827 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40828 if (!SWIG_IsOK(ecode2)) {
40829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
40830 }
40831 arg2 = static_cast< size_t >(val2);
40832 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40833 if (!SWIG_IsOK(ecode3)) {
40834 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
40835 }
40836 arg3 = static_cast< bool >(val3);
40837 {
40838 PyThreadState* __tstate = wxPyBeginAllowThreads();
40839 (arg1)->EnableTop(arg2,arg3);
40840 wxPyEndAllowThreads(__tstate);
40841 if (PyErr_Occurred()) SWIG_fail;
40842 }
40843 resultobj = SWIG_Py_Void();
40844 return resultobj;
40845 fail:
40846 return NULL;
40847 }
40848
40849
40850 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40851 PyObject *resultobj = 0;
40852 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40853 size_t arg2 ;
40854 bool result;
40855 void *argp1 = 0 ;
40856 int res1 = 0 ;
40857 size_t val2 ;
40858 int ecode2 = 0 ;
40859 PyObject * obj0 = 0 ;
40860 PyObject * obj1 = 0 ;
40861 char * kwnames[] = {
40862 (char *) "self",(char *) "pos", NULL
40863 };
40864
40865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
40866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40867 if (!SWIG_IsOK(res1)) {
40868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40869 }
40870 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40871 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40872 if (!SWIG_IsOK(ecode2)) {
40873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
40874 }
40875 arg2 = static_cast< size_t >(val2);
40876 {
40877 PyThreadState* __tstate = wxPyBeginAllowThreads();
40878 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
40879 wxPyEndAllowThreads(__tstate);
40880 if (PyErr_Occurred()) SWIG_fail;
40881 }
40882 {
40883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40884 }
40885 return resultobj;
40886 fail:
40887 return NULL;
40888 }
40889
40890
40891 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40892 PyObject *resultobj = 0;
40893 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40894 size_t arg2 ;
40895 wxString *arg3 = 0 ;
40896 void *argp1 = 0 ;
40897 int res1 = 0 ;
40898 size_t val2 ;
40899 int ecode2 = 0 ;
40900 bool temp3 = false ;
40901 PyObject * obj0 = 0 ;
40902 PyObject * obj1 = 0 ;
40903 PyObject * obj2 = 0 ;
40904 char * kwnames[] = {
40905 (char *) "self",(char *) "pos",(char *) "label", NULL
40906 };
40907
40908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40910 if (!SWIG_IsOK(res1)) {
40911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40912 }
40913 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40914 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40915 if (!SWIG_IsOK(ecode2)) {
40916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
40917 }
40918 arg2 = static_cast< size_t >(val2);
40919 {
40920 arg3 = wxString_in_helper(obj2);
40921 if (arg3 == NULL) SWIG_fail;
40922 temp3 = true;
40923 }
40924 {
40925 PyThreadState* __tstate = wxPyBeginAllowThreads();
40926 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
40927 wxPyEndAllowThreads(__tstate);
40928 if (PyErr_Occurred()) SWIG_fail;
40929 }
40930 resultobj = SWIG_Py_Void();
40931 {
40932 if (temp3)
40933 delete arg3;
40934 }
40935 return resultobj;
40936 fail:
40937 {
40938 if (temp3)
40939 delete arg3;
40940 }
40941 return NULL;
40942 }
40943
40944
40945 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40946 PyObject *resultobj = 0;
40947 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40948 size_t arg2 ;
40949 wxString result;
40950 void *argp1 = 0 ;
40951 int res1 = 0 ;
40952 size_t val2 ;
40953 int ecode2 = 0 ;
40954 PyObject * obj0 = 0 ;
40955 PyObject * obj1 = 0 ;
40956 char * kwnames[] = {
40957 (char *) "self",(char *) "pos", NULL
40958 };
40959
40960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
40961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40962 if (!SWIG_IsOK(res1)) {
40963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40964 }
40965 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40966 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40967 if (!SWIG_IsOK(ecode2)) {
40968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
40969 }
40970 arg2 = static_cast< size_t >(val2);
40971 {
40972 PyThreadState* __tstate = wxPyBeginAllowThreads();
40973 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
40974 wxPyEndAllowThreads(__tstate);
40975 if (PyErr_Occurred()) SWIG_fail;
40976 }
40977 {
40978 #if wxUSE_UNICODE
40979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40980 #else
40981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40982 #endif
40983 }
40984 return resultobj;
40985 fail:
40986 return NULL;
40987 }
40988
40989
40990 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40991 PyObject *resultobj = 0;
40992 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40993 wxString *arg2 = 0 ;
40994 wxString *arg3 = 0 ;
40995 int result;
40996 void *argp1 = 0 ;
40997 int res1 = 0 ;
40998 bool temp2 = false ;
40999 bool temp3 = false ;
41000 PyObject * obj0 = 0 ;
41001 PyObject * obj1 = 0 ;
41002 PyObject * obj2 = 0 ;
41003 char * kwnames[] = {
41004 (char *) "self",(char *) "menu",(char *) "item", NULL
41005 };
41006
41007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41009 if (!SWIG_IsOK(res1)) {
41010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41011 }
41012 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41013 {
41014 arg2 = wxString_in_helper(obj1);
41015 if (arg2 == NULL) SWIG_fail;
41016 temp2 = true;
41017 }
41018 {
41019 arg3 = wxString_in_helper(obj2);
41020 if (arg3 == NULL) SWIG_fail;
41021 temp3 = true;
41022 }
41023 {
41024 PyThreadState* __tstate = wxPyBeginAllowThreads();
41025 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41026 wxPyEndAllowThreads(__tstate);
41027 if (PyErr_Occurred()) SWIG_fail;
41028 }
41029 resultobj = SWIG_From_int(static_cast< int >(result));
41030 {
41031 if (temp2)
41032 delete arg2;
41033 }
41034 {
41035 if (temp3)
41036 delete arg3;
41037 }
41038 return resultobj;
41039 fail:
41040 {
41041 if (temp2)
41042 delete arg2;
41043 }
41044 {
41045 if (temp3)
41046 delete arg3;
41047 }
41048 return NULL;
41049 }
41050
41051
41052 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41053 PyObject *resultobj = 0;
41054 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41055 int arg2 ;
41056 wxMenuItem *result = 0 ;
41057 void *argp1 = 0 ;
41058 int res1 = 0 ;
41059 int val2 ;
41060 int ecode2 = 0 ;
41061 PyObject * obj0 = 0 ;
41062 PyObject * obj1 = 0 ;
41063 char * kwnames[] = {
41064 (char *) "self",(char *) "id", NULL
41065 };
41066
41067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41069 if (!SWIG_IsOK(res1)) {
41070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41071 }
41072 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41073 ecode2 = SWIG_AsVal_int(obj1, &val2);
41074 if (!SWIG_IsOK(ecode2)) {
41075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41076 }
41077 arg2 = static_cast< int >(val2);
41078 {
41079 PyThreadState* __tstate = wxPyBeginAllowThreads();
41080 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41081 wxPyEndAllowThreads(__tstate);
41082 if (PyErr_Occurred()) SWIG_fail;
41083 }
41084 {
41085 resultobj = wxPyMake_wxObject(result, (bool)0);
41086 }
41087 return resultobj;
41088 fail:
41089 return NULL;
41090 }
41091
41092
41093 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41094 PyObject *resultobj = 0;
41095 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41096 wxString *arg2 = 0 ;
41097 int result;
41098 void *argp1 = 0 ;
41099 int res1 = 0 ;
41100 bool temp2 = false ;
41101 PyObject * obj0 = 0 ;
41102 PyObject * obj1 = 0 ;
41103 char * kwnames[] = {
41104 (char *) "self",(char *) "title", NULL
41105 };
41106
41107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41109 if (!SWIG_IsOK(res1)) {
41110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41111 }
41112 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41113 {
41114 arg2 = wxString_in_helper(obj1);
41115 if (arg2 == NULL) SWIG_fail;
41116 temp2 = true;
41117 }
41118 {
41119 PyThreadState* __tstate = wxPyBeginAllowThreads();
41120 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41121 wxPyEndAllowThreads(__tstate);
41122 if (PyErr_Occurred()) SWIG_fail;
41123 }
41124 resultobj = SWIG_From_int(static_cast< int >(result));
41125 {
41126 if (temp2)
41127 delete arg2;
41128 }
41129 return resultobj;
41130 fail:
41131 {
41132 if (temp2)
41133 delete arg2;
41134 }
41135 return NULL;
41136 }
41137
41138
41139 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41140 PyObject *resultobj = 0;
41141 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41142 int arg2 ;
41143 bool arg3 ;
41144 void *argp1 = 0 ;
41145 int res1 = 0 ;
41146 int val2 ;
41147 int ecode2 = 0 ;
41148 bool val3 ;
41149 int ecode3 = 0 ;
41150 PyObject * obj0 = 0 ;
41151 PyObject * obj1 = 0 ;
41152 PyObject * obj2 = 0 ;
41153 char * kwnames[] = {
41154 (char *) "self",(char *) "id",(char *) "enable", NULL
41155 };
41156
41157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41159 if (!SWIG_IsOK(res1)) {
41160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41161 }
41162 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41163 ecode2 = SWIG_AsVal_int(obj1, &val2);
41164 if (!SWIG_IsOK(ecode2)) {
41165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41166 }
41167 arg2 = static_cast< int >(val2);
41168 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41169 if (!SWIG_IsOK(ecode3)) {
41170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41171 }
41172 arg3 = static_cast< bool >(val3);
41173 {
41174 PyThreadState* __tstate = wxPyBeginAllowThreads();
41175 (arg1)->Enable(arg2,arg3);
41176 wxPyEndAllowThreads(__tstate);
41177 if (PyErr_Occurred()) SWIG_fail;
41178 }
41179 resultobj = SWIG_Py_Void();
41180 return resultobj;
41181 fail:
41182 return NULL;
41183 }
41184
41185
41186 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41187 PyObject *resultobj = 0;
41188 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41189 int arg2 ;
41190 bool arg3 ;
41191 void *argp1 = 0 ;
41192 int res1 = 0 ;
41193 int val2 ;
41194 int ecode2 = 0 ;
41195 bool val3 ;
41196 int ecode3 = 0 ;
41197 PyObject * obj0 = 0 ;
41198 PyObject * obj1 = 0 ;
41199 PyObject * obj2 = 0 ;
41200 char * kwnames[] = {
41201 (char *) "self",(char *) "id",(char *) "check", NULL
41202 };
41203
41204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41206 if (!SWIG_IsOK(res1)) {
41207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41208 }
41209 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41210 ecode2 = SWIG_AsVal_int(obj1, &val2);
41211 if (!SWIG_IsOK(ecode2)) {
41212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41213 }
41214 arg2 = static_cast< int >(val2);
41215 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41216 if (!SWIG_IsOK(ecode3)) {
41217 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41218 }
41219 arg3 = static_cast< bool >(val3);
41220 {
41221 PyThreadState* __tstate = wxPyBeginAllowThreads();
41222 (arg1)->Check(arg2,arg3);
41223 wxPyEndAllowThreads(__tstate);
41224 if (PyErr_Occurred()) SWIG_fail;
41225 }
41226 resultobj = SWIG_Py_Void();
41227 return resultobj;
41228 fail:
41229 return NULL;
41230 }
41231
41232
41233 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41234 PyObject *resultobj = 0;
41235 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41236 int arg2 ;
41237 bool result;
41238 void *argp1 = 0 ;
41239 int res1 = 0 ;
41240 int val2 ;
41241 int ecode2 = 0 ;
41242 PyObject * obj0 = 0 ;
41243 PyObject * obj1 = 0 ;
41244 char * kwnames[] = {
41245 (char *) "self",(char *) "id", NULL
41246 };
41247
41248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41250 if (!SWIG_IsOK(res1)) {
41251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41252 }
41253 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41254 ecode2 = SWIG_AsVal_int(obj1, &val2);
41255 if (!SWIG_IsOK(ecode2)) {
41256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41257 }
41258 arg2 = static_cast< int >(val2);
41259 {
41260 PyThreadState* __tstate = wxPyBeginAllowThreads();
41261 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41262 wxPyEndAllowThreads(__tstate);
41263 if (PyErr_Occurred()) SWIG_fail;
41264 }
41265 {
41266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41267 }
41268 return resultobj;
41269 fail:
41270 return NULL;
41271 }
41272
41273
41274 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41275 PyObject *resultobj = 0;
41276 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41277 int arg2 ;
41278 bool result;
41279 void *argp1 = 0 ;
41280 int res1 = 0 ;
41281 int val2 ;
41282 int ecode2 = 0 ;
41283 PyObject * obj0 = 0 ;
41284 PyObject * obj1 = 0 ;
41285 char * kwnames[] = {
41286 (char *) "self",(char *) "id", NULL
41287 };
41288
41289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41291 if (!SWIG_IsOK(res1)) {
41292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41293 }
41294 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41295 ecode2 = SWIG_AsVal_int(obj1, &val2);
41296 if (!SWIG_IsOK(ecode2)) {
41297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41298 }
41299 arg2 = static_cast< int >(val2);
41300 {
41301 PyThreadState* __tstate = wxPyBeginAllowThreads();
41302 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41303 wxPyEndAllowThreads(__tstate);
41304 if (PyErr_Occurred()) SWIG_fail;
41305 }
41306 {
41307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41308 }
41309 return resultobj;
41310 fail:
41311 return NULL;
41312 }
41313
41314
41315 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41316 PyObject *resultobj = 0;
41317 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41318 int arg2 ;
41319 wxString *arg3 = 0 ;
41320 void *argp1 = 0 ;
41321 int res1 = 0 ;
41322 int val2 ;
41323 int ecode2 = 0 ;
41324 bool temp3 = false ;
41325 PyObject * obj0 = 0 ;
41326 PyObject * obj1 = 0 ;
41327 PyObject * obj2 = 0 ;
41328 char * kwnames[] = {
41329 (char *) "self",(char *) "id",(char *) "label", NULL
41330 };
41331
41332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41334 if (!SWIG_IsOK(res1)) {
41335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41336 }
41337 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41338 ecode2 = SWIG_AsVal_int(obj1, &val2);
41339 if (!SWIG_IsOK(ecode2)) {
41340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41341 }
41342 arg2 = static_cast< int >(val2);
41343 {
41344 arg3 = wxString_in_helper(obj2);
41345 if (arg3 == NULL) SWIG_fail;
41346 temp3 = true;
41347 }
41348 {
41349 PyThreadState* __tstate = wxPyBeginAllowThreads();
41350 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41351 wxPyEndAllowThreads(__tstate);
41352 if (PyErr_Occurred()) SWIG_fail;
41353 }
41354 resultobj = SWIG_Py_Void();
41355 {
41356 if (temp3)
41357 delete arg3;
41358 }
41359 return resultobj;
41360 fail:
41361 {
41362 if (temp3)
41363 delete arg3;
41364 }
41365 return NULL;
41366 }
41367
41368
41369 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41370 PyObject *resultobj = 0;
41371 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41372 int arg2 ;
41373 wxString result;
41374 void *argp1 = 0 ;
41375 int res1 = 0 ;
41376 int val2 ;
41377 int ecode2 = 0 ;
41378 PyObject * obj0 = 0 ;
41379 PyObject * obj1 = 0 ;
41380 char * kwnames[] = {
41381 (char *) "self",(char *) "id", NULL
41382 };
41383
41384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41386 if (!SWIG_IsOK(res1)) {
41387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41388 }
41389 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41390 ecode2 = SWIG_AsVal_int(obj1, &val2);
41391 if (!SWIG_IsOK(ecode2)) {
41392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41393 }
41394 arg2 = static_cast< int >(val2);
41395 {
41396 PyThreadState* __tstate = wxPyBeginAllowThreads();
41397 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41398 wxPyEndAllowThreads(__tstate);
41399 if (PyErr_Occurred()) SWIG_fail;
41400 }
41401 {
41402 #if wxUSE_UNICODE
41403 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41404 #else
41405 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41406 #endif
41407 }
41408 return resultobj;
41409 fail:
41410 return NULL;
41411 }
41412
41413
41414 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41415 PyObject *resultobj = 0;
41416 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41417 int arg2 ;
41418 wxString *arg3 = 0 ;
41419 void *argp1 = 0 ;
41420 int res1 = 0 ;
41421 int val2 ;
41422 int ecode2 = 0 ;
41423 bool temp3 = false ;
41424 PyObject * obj0 = 0 ;
41425 PyObject * obj1 = 0 ;
41426 PyObject * obj2 = 0 ;
41427 char * kwnames[] = {
41428 (char *) "self",(char *) "id",(char *) "helpString", NULL
41429 };
41430
41431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41433 if (!SWIG_IsOK(res1)) {
41434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41435 }
41436 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41437 ecode2 = SWIG_AsVal_int(obj1, &val2);
41438 if (!SWIG_IsOK(ecode2)) {
41439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41440 }
41441 arg2 = static_cast< int >(val2);
41442 {
41443 arg3 = wxString_in_helper(obj2);
41444 if (arg3 == NULL) SWIG_fail;
41445 temp3 = true;
41446 }
41447 {
41448 PyThreadState* __tstate = wxPyBeginAllowThreads();
41449 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41450 wxPyEndAllowThreads(__tstate);
41451 if (PyErr_Occurred()) SWIG_fail;
41452 }
41453 resultobj = SWIG_Py_Void();
41454 {
41455 if (temp3)
41456 delete arg3;
41457 }
41458 return resultobj;
41459 fail:
41460 {
41461 if (temp3)
41462 delete arg3;
41463 }
41464 return NULL;
41465 }
41466
41467
41468 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41469 PyObject *resultobj = 0;
41470 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41471 int arg2 ;
41472 wxString result;
41473 void *argp1 = 0 ;
41474 int res1 = 0 ;
41475 int val2 ;
41476 int ecode2 = 0 ;
41477 PyObject * obj0 = 0 ;
41478 PyObject * obj1 = 0 ;
41479 char * kwnames[] = {
41480 (char *) "self",(char *) "id", NULL
41481 };
41482
41483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41485 if (!SWIG_IsOK(res1)) {
41486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41487 }
41488 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41489 ecode2 = SWIG_AsVal_int(obj1, &val2);
41490 if (!SWIG_IsOK(ecode2)) {
41491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41492 }
41493 arg2 = static_cast< int >(val2);
41494 {
41495 PyThreadState* __tstate = wxPyBeginAllowThreads();
41496 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41497 wxPyEndAllowThreads(__tstate);
41498 if (PyErr_Occurred()) SWIG_fail;
41499 }
41500 {
41501 #if wxUSE_UNICODE
41502 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41503 #else
41504 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41505 #endif
41506 }
41507 return resultobj;
41508 fail:
41509 return NULL;
41510 }
41511
41512
41513 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41514 PyObject *resultobj = 0;
41515 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41516 wxFrame *result = 0 ;
41517 void *argp1 = 0 ;
41518 int res1 = 0 ;
41519 PyObject *swig_obj[1] ;
41520
41521 if (!args) SWIG_fail;
41522 swig_obj[0] = args;
41523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41524 if (!SWIG_IsOK(res1)) {
41525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41526 }
41527 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41528 {
41529 PyThreadState* __tstate = wxPyBeginAllowThreads();
41530 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41531 wxPyEndAllowThreads(__tstate);
41532 if (PyErr_Occurred()) SWIG_fail;
41533 }
41534 {
41535 resultobj = wxPyMake_wxObject(result, (bool)0);
41536 }
41537 return resultobj;
41538 fail:
41539 return NULL;
41540 }
41541
41542
41543 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41544 PyObject *resultobj = 0;
41545 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41546 bool result;
41547 void *argp1 = 0 ;
41548 int res1 = 0 ;
41549 PyObject *swig_obj[1] ;
41550
41551 if (!args) SWIG_fail;
41552 swig_obj[0] = args;
41553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41554 if (!SWIG_IsOK(res1)) {
41555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41556 }
41557 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41558 {
41559 PyThreadState* __tstate = wxPyBeginAllowThreads();
41560 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41561 wxPyEndAllowThreads(__tstate);
41562 if (PyErr_Occurred()) SWIG_fail;
41563 }
41564 {
41565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41566 }
41567 return resultobj;
41568 fail:
41569 return NULL;
41570 }
41571
41572
41573 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41574 PyObject *resultobj = 0;
41575 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41576 wxFrame *arg2 = (wxFrame *) 0 ;
41577 void *argp1 = 0 ;
41578 int res1 = 0 ;
41579 void *argp2 = 0 ;
41580 int res2 = 0 ;
41581 PyObject * obj0 = 0 ;
41582 PyObject * obj1 = 0 ;
41583 char * kwnames[] = {
41584 (char *) "self",(char *) "frame", NULL
41585 };
41586
41587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41589 if (!SWIG_IsOK(res1)) {
41590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41591 }
41592 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41593 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41594 if (!SWIG_IsOK(res2)) {
41595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41596 }
41597 arg2 = reinterpret_cast< wxFrame * >(argp2);
41598 {
41599 PyThreadState* __tstate = wxPyBeginAllowThreads();
41600 (arg1)->Attach(arg2);
41601 wxPyEndAllowThreads(__tstate);
41602 if (PyErr_Occurred()) SWIG_fail;
41603 }
41604 resultobj = SWIG_Py_Void();
41605 return resultobj;
41606 fail:
41607 return NULL;
41608 }
41609
41610
41611 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41612 PyObject *resultobj = 0;
41613 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41614 void *argp1 = 0 ;
41615 int res1 = 0 ;
41616 PyObject *swig_obj[1] ;
41617
41618 if (!args) SWIG_fail;
41619 swig_obj[0] = args;
41620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41621 if (!SWIG_IsOK(res1)) {
41622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41623 }
41624 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41625 {
41626 PyThreadState* __tstate = wxPyBeginAllowThreads();
41627 (arg1)->Detach();
41628 wxPyEndAllowThreads(__tstate);
41629 if (PyErr_Occurred()) SWIG_fail;
41630 }
41631 resultobj = SWIG_Py_Void();
41632 return resultobj;
41633 fail:
41634 return NULL;
41635 }
41636
41637
41638 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41639 PyObject *resultobj = 0;
41640 bool arg1 ;
41641 bool val1 ;
41642 int ecode1 = 0 ;
41643 PyObject * obj0 = 0 ;
41644 char * kwnames[] = {
41645 (char *) "enable", NULL
41646 };
41647
41648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41649 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41650 if (!SWIG_IsOK(ecode1)) {
41651 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41652 }
41653 arg1 = static_cast< bool >(val1);
41654 {
41655 PyThreadState* __tstate = wxPyBeginAllowThreads();
41656 wxMenuBar_SetAutoWindowMenu(arg1);
41657 wxPyEndAllowThreads(__tstate);
41658 if (PyErr_Occurred()) SWIG_fail;
41659 }
41660 resultobj = SWIG_Py_Void();
41661 return resultobj;
41662 fail:
41663 return NULL;
41664 }
41665
41666
41667 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41668 PyObject *resultobj = 0;
41669 bool result;
41670
41671 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41672 {
41673 PyThreadState* __tstate = wxPyBeginAllowThreads();
41674 result = (bool)wxMenuBar_GetAutoWindowMenu();
41675 wxPyEndAllowThreads(__tstate);
41676 if (PyErr_Occurred()) SWIG_fail;
41677 }
41678 {
41679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41680 }
41681 return resultobj;
41682 fail:
41683 return NULL;
41684 }
41685
41686
41687 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41688 PyObject *obj;
41689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41690 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41691 return SWIG_Py_Void();
41692 }
41693
41694 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41695 return SWIG_Python_InitShadowInstance(args);
41696 }
41697
41698 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41699 PyObject *resultobj = 0;
41700 wxMenu *arg1 = (wxMenu *) NULL ;
41701 int arg2 = (int) wxID_ANY ;
41702 wxString const &arg3_defvalue = wxPyEmptyString ;
41703 wxString *arg3 = (wxString *) &arg3_defvalue ;
41704 wxString const &arg4_defvalue = wxPyEmptyString ;
41705 wxString *arg4 = (wxString *) &arg4_defvalue ;
41706 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41707 wxMenu *arg6 = (wxMenu *) NULL ;
41708 wxMenuItem *result = 0 ;
41709 void *argp1 = 0 ;
41710 int res1 = 0 ;
41711 int val2 ;
41712 int ecode2 = 0 ;
41713 bool temp3 = false ;
41714 bool temp4 = false ;
41715 int val5 ;
41716 int ecode5 = 0 ;
41717 void *argp6 = 0 ;
41718 int res6 = 0 ;
41719 PyObject * obj0 = 0 ;
41720 PyObject * obj1 = 0 ;
41721 PyObject * obj2 = 0 ;
41722 PyObject * obj3 = 0 ;
41723 PyObject * obj4 = 0 ;
41724 PyObject * obj5 = 0 ;
41725 char * kwnames[] = {
41726 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41727 };
41728
41729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
41730 if (obj0) {
41731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41732 if (!SWIG_IsOK(res1)) {
41733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41734 }
41735 arg1 = reinterpret_cast< wxMenu * >(argp1);
41736 }
41737 if (obj1) {
41738 ecode2 = SWIG_AsVal_int(obj1, &val2);
41739 if (!SWIG_IsOK(ecode2)) {
41740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
41741 }
41742 arg2 = static_cast< int >(val2);
41743 }
41744 if (obj2) {
41745 {
41746 arg3 = wxString_in_helper(obj2);
41747 if (arg3 == NULL) SWIG_fail;
41748 temp3 = true;
41749 }
41750 }
41751 if (obj3) {
41752 {
41753 arg4 = wxString_in_helper(obj3);
41754 if (arg4 == NULL) SWIG_fail;
41755 temp4 = true;
41756 }
41757 }
41758 if (obj4) {
41759 ecode5 = SWIG_AsVal_int(obj4, &val5);
41760 if (!SWIG_IsOK(ecode5)) {
41761 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
41762 }
41763 arg5 = static_cast< wxItemKind >(val5);
41764 }
41765 if (obj5) {
41766 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
41767 if (!SWIG_IsOK(res6)) {
41768 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
41769 }
41770 arg6 = reinterpret_cast< wxMenu * >(argp6);
41771 }
41772 {
41773 PyThreadState* __tstate = wxPyBeginAllowThreads();
41774 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
41775 wxPyEndAllowThreads(__tstate);
41776 if (PyErr_Occurred()) SWIG_fail;
41777 }
41778 {
41779 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
41780 }
41781 {
41782 if (temp3)
41783 delete arg3;
41784 }
41785 {
41786 if (temp4)
41787 delete arg4;
41788 }
41789 return resultobj;
41790 fail:
41791 {
41792 if (temp3)
41793 delete arg3;
41794 }
41795 {
41796 if (temp4)
41797 delete arg4;
41798 }
41799 return NULL;
41800 }
41801
41802
41803 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41804 PyObject *resultobj = 0;
41805 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41806 void *argp1 = 0 ;
41807 int res1 = 0 ;
41808 PyObject *swig_obj[1] ;
41809
41810 if (!args) SWIG_fail;
41811 swig_obj[0] = args;
41812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
41813 if (!SWIG_IsOK(res1)) {
41814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41815 }
41816 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41817 {
41818 PyThreadState* __tstate = wxPyBeginAllowThreads();
41819 delete arg1;
41820
41821 wxPyEndAllowThreads(__tstate);
41822 if (PyErr_Occurred()) SWIG_fail;
41823 }
41824 resultobj = SWIG_Py_Void();
41825 return resultobj;
41826 fail:
41827 return NULL;
41828 }
41829
41830
41831 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41832 PyObject *resultobj = 0;
41833 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41834 wxMenu *result = 0 ;
41835 void *argp1 = 0 ;
41836 int res1 = 0 ;
41837 PyObject *swig_obj[1] ;
41838
41839 if (!args) SWIG_fail;
41840 swig_obj[0] = args;
41841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41842 if (!SWIG_IsOK(res1)) {
41843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
41844 }
41845 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41846 {
41847 PyThreadState* __tstate = wxPyBeginAllowThreads();
41848 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
41849 wxPyEndAllowThreads(__tstate);
41850 if (PyErr_Occurred()) SWIG_fail;
41851 }
41852 {
41853 resultobj = wxPyMake_wxObject(result, 0);
41854 }
41855 return resultobj;
41856 fail:
41857 return NULL;
41858 }
41859
41860
41861 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41862 PyObject *resultobj = 0;
41863 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41864 wxMenu *arg2 = (wxMenu *) 0 ;
41865 void *argp1 = 0 ;
41866 int res1 = 0 ;
41867 void *argp2 = 0 ;
41868 int res2 = 0 ;
41869 PyObject * obj0 = 0 ;
41870 PyObject * obj1 = 0 ;
41871 char * kwnames[] = {
41872 (char *) "self",(char *) "menu", NULL
41873 };
41874
41875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41877 if (!SWIG_IsOK(res1)) {
41878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41879 }
41880 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41881 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41882 if (!SWIG_IsOK(res2)) {
41883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
41884 }
41885 arg2 = reinterpret_cast< wxMenu * >(argp2);
41886 {
41887 PyThreadState* __tstate = wxPyBeginAllowThreads();
41888 (arg1)->SetMenu(arg2);
41889 wxPyEndAllowThreads(__tstate);
41890 if (PyErr_Occurred()) SWIG_fail;
41891 }
41892 resultobj = SWIG_Py_Void();
41893 return resultobj;
41894 fail:
41895 return NULL;
41896 }
41897
41898
41899 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41900 PyObject *resultobj = 0;
41901 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41902 int arg2 ;
41903 void *argp1 = 0 ;
41904 int res1 = 0 ;
41905 int val2 ;
41906 int ecode2 = 0 ;
41907 PyObject * obj0 = 0 ;
41908 PyObject * obj1 = 0 ;
41909 char * kwnames[] = {
41910 (char *) "self",(char *) "id", NULL
41911 };
41912
41913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
41914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41915 if (!SWIG_IsOK(res1)) {
41916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41917 }
41918 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41919 ecode2 = SWIG_AsVal_int(obj1, &val2);
41920 if (!SWIG_IsOK(ecode2)) {
41921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
41922 }
41923 arg2 = static_cast< int >(val2);
41924 {
41925 PyThreadState* __tstate = wxPyBeginAllowThreads();
41926 (arg1)->SetId(arg2);
41927 wxPyEndAllowThreads(__tstate);
41928 if (PyErr_Occurred()) SWIG_fail;
41929 }
41930 resultobj = SWIG_Py_Void();
41931 return resultobj;
41932 fail:
41933 return NULL;
41934 }
41935
41936
41937 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41938 PyObject *resultobj = 0;
41939 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41940 int result;
41941 void *argp1 = 0 ;
41942 int res1 = 0 ;
41943 PyObject *swig_obj[1] ;
41944
41945 if (!args) SWIG_fail;
41946 swig_obj[0] = args;
41947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41948 if (!SWIG_IsOK(res1)) {
41949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
41950 }
41951 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41952 {
41953 PyThreadState* __tstate = wxPyBeginAllowThreads();
41954 result = (int)((wxMenuItem const *)arg1)->GetId();
41955 wxPyEndAllowThreads(__tstate);
41956 if (PyErr_Occurred()) SWIG_fail;
41957 }
41958 resultobj = SWIG_From_int(static_cast< int >(result));
41959 return resultobj;
41960 fail:
41961 return NULL;
41962 }
41963
41964
41965 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41966 PyObject *resultobj = 0;
41967 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41968 bool result;
41969 void *argp1 = 0 ;
41970 int res1 = 0 ;
41971 PyObject *swig_obj[1] ;
41972
41973 if (!args) SWIG_fail;
41974 swig_obj[0] = args;
41975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41976 if (!SWIG_IsOK(res1)) {
41977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
41978 }
41979 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41980 {
41981 PyThreadState* __tstate = wxPyBeginAllowThreads();
41982 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
41983 wxPyEndAllowThreads(__tstate);
41984 if (PyErr_Occurred()) SWIG_fail;
41985 }
41986 {
41987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41988 }
41989 return resultobj;
41990 fail:
41991 return NULL;
41992 }
41993
41994
41995 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41996 PyObject *resultobj = 0;
41997 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41998 wxString *arg2 = 0 ;
41999 void *argp1 = 0 ;
42000 int res1 = 0 ;
42001 bool temp2 = false ;
42002 PyObject * obj0 = 0 ;
42003 PyObject * obj1 = 0 ;
42004 char * kwnames[] = {
42005 (char *) "self",(char *) "str", NULL
42006 };
42007
42008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42010 if (!SWIG_IsOK(res1)) {
42011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42012 }
42013 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42014 {
42015 arg2 = wxString_in_helper(obj1);
42016 if (arg2 == NULL) SWIG_fail;
42017 temp2 = true;
42018 }
42019 {
42020 PyThreadState* __tstate = wxPyBeginAllowThreads();
42021 (arg1)->SetText((wxString const &)*arg2);
42022 wxPyEndAllowThreads(__tstate);
42023 if (PyErr_Occurred()) SWIG_fail;
42024 }
42025 resultobj = SWIG_Py_Void();
42026 {
42027 if (temp2)
42028 delete arg2;
42029 }
42030 return resultobj;
42031 fail:
42032 {
42033 if (temp2)
42034 delete arg2;
42035 }
42036 return NULL;
42037 }
42038
42039
42040 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42041 PyObject *resultobj = 0;
42042 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42043 wxString result;
42044 void *argp1 = 0 ;
42045 int res1 = 0 ;
42046 PyObject *swig_obj[1] ;
42047
42048 if (!args) SWIG_fail;
42049 swig_obj[0] = args;
42050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42051 if (!SWIG_IsOK(res1)) {
42052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42053 }
42054 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42055 {
42056 PyThreadState* __tstate = wxPyBeginAllowThreads();
42057 result = ((wxMenuItem const *)arg1)->GetLabel();
42058 wxPyEndAllowThreads(__tstate);
42059 if (PyErr_Occurred()) SWIG_fail;
42060 }
42061 {
42062 #if wxUSE_UNICODE
42063 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42064 #else
42065 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42066 #endif
42067 }
42068 return resultobj;
42069 fail:
42070 return NULL;
42071 }
42072
42073
42074 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42075 PyObject *resultobj = 0;
42076 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42077 wxString *result = 0 ;
42078 void *argp1 = 0 ;
42079 int res1 = 0 ;
42080 PyObject *swig_obj[1] ;
42081
42082 if (!args) SWIG_fail;
42083 swig_obj[0] = args;
42084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42085 if (!SWIG_IsOK(res1)) {
42086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42087 }
42088 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42089 {
42090 PyThreadState* __tstate = wxPyBeginAllowThreads();
42091 {
42092 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42093 result = (wxString *) &_result_ref;
42094 }
42095 wxPyEndAllowThreads(__tstate);
42096 if (PyErr_Occurred()) SWIG_fail;
42097 }
42098 {
42099 #if wxUSE_UNICODE
42100 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42101 #else
42102 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42103 #endif
42104 }
42105 return resultobj;
42106 fail:
42107 return NULL;
42108 }
42109
42110
42111 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42112 PyObject *resultobj = 0;
42113 wxString *arg1 = 0 ;
42114 wxString result;
42115 bool temp1 = false ;
42116 PyObject * obj0 = 0 ;
42117 char * kwnames[] = {
42118 (char *) "text", NULL
42119 };
42120
42121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42122 {
42123 arg1 = wxString_in_helper(obj0);
42124 if (arg1 == NULL) SWIG_fail;
42125 temp1 = true;
42126 }
42127 {
42128 PyThreadState* __tstate = wxPyBeginAllowThreads();
42129 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42130 wxPyEndAllowThreads(__tstate);
42131 if (PyErr_Occurred()) SWIG_fail;
42132 }
42133 {
42134 #if wxUSE_UNICODE
42135 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42136 #else
42137 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42138 #endif
42139 }
42140 {
42141 if (temp1)
42142 delete arg1;
42143 }
42144 return resultobj;
42145 fail:
42146 {
42147 if (temp1)
42148 delete arg1;
42149 }
42150 return NULL;
42151 }
42152
42153
42154 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42155 PyObject *resultobj = 0;
42156 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42157 wxItemKind result;
42158 void *argp1 = 0 ;
42159 int res1 = 0 ;
42160 PyObject *swig_obj[1] ;
42161
42162 if (!args) SWIG_fail;
42163 swig_obj[0] = args;
42164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42165 if (!SWIG_IsOK(res1)) {
42166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42167 }
42168 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42169 {
42170 PyThreadState* __tstate = wxPyBeginAllowThreads();
42171 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42172 wxPyEndAllowThreads(__tstate);
42173 if (PyErr_Occurred()) SWIG_fail;
42174 }
42175 resultobj = SWIG_From_int(static_cast< int >(result));
42176 return resultobj;
42177 fail:
42178 return NULL;
42179 }
42180
42181
42182 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42183 PyObject *resultobj = 0;
42184 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42185 wxItemKind arg2 ;
42186 void *argp1 = 0 ;
42187 int res1 = 0 ;
42188 int val2 ;
42189 int ecode2 = 0 ;
42190 PyObject * obj0 = 0 ;
42191 PyObject * obj1 = 0 ;
42192 char * kwnames[] = {
42193 (char *) "self",(char *) "kind", NULL
42194 };
42195
42196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42198 if (!SWIG_IsOK(res1)) {
42199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42200 }
42201 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42202 ecode2 = SWIG_AsVal_int(obj1, &val2);
42203 if (!SWIG_IsOK(ecode2)) {
42204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42205 }
42206 arg2 = static_cast< wxItemKind >(val2);
42207 {
42208 PyThreadState* __tstate = wxPyBeginAllowThreads();
42209 (arg1)->SetKind(arg2);
42210 wxPyEndAllowThreads(__tstate);
42211 if (PyErr_Occurred()) SWIG_fail;
42212 }
42213 resultobj = SWIG_Py_Void();
42214 return resultobj;
42215 fail:
42216 return NULL;
42217 }
42218
42219
42220 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42221 PyObject *resultobj = 0;
42222 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42223 bool arg2 ;
42224 void *argp1 = 0 ;
42225 int res1 = 0 ;
42226 bool val2 ;
42227 int ecode2 = 0 ;
42228 PyObject * obj0 = 0 ;
42229 PyObject * obj1 = 0 ;
42230 char * kwnames[] = {
42231 (char *) "self",(char *) "checkable", NULL
42232 };
42233
42234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42236 if (!SWIG_IsOK(res1)) {
42237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42238 }
42239 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42240 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42241 if (!SWIG_IsOK(ecode2)) {
42242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42243 }
42244 arg2 = static_cast< bool >(val2);
42245 {
42246 PyThreadState* __tstate = wxPyBeginAllowThreads();
42247 (arg1)->SetCheckable(arg2);
42248 wxPyEndAllowThreads(__tstate);
42249 if (PyErr_Occurred()) SWIG_fail;
42250 }
42251 resultobj = SWIG_Py_Void();
42252 return resultobj;
42253 fail:
42254 return NULL;
42255 }
42256
42257
42258 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42259 PyObject *resultobj = 0;
42260 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42261 bool result;
42262 void *argp1 = 0 ;
42263 int res1 = 0 ;
42264 PyObject *swig_obj[1] ;
42265
42266 if (!args) SWIG_fail;
42267 swig_obj[0] = args;
42268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42269 if (!SWIG_IsOK(res1)) {
42270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42271 }
42272 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42273 {
42274 PyThreadState* __tstate = wxPyBeginAllowThreads();
42275 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42276 wxPyEndAllowThreads(__tstate);
42277 if (PyErr_Occurred()) SWIG_fail;
42278 }
42279 {
42280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42281 }
42282 return resultobj;
42283 fail:
42284 return NULL;
42285 }
42286
42287
42288 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42289 PyObject *resultobj = 0;
42290 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42291 bool result;
42292 void *argp1 = 0 ;
42293 int res1 = 0 ;
42294 PyObject *swig_obj[1] ;
42295
42296 if (!args) SWIG_fail;
42297 swig_obj[0] = args;
42298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42299 if (!SWIG_IsOK(res1)) {
42300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42301 }
42302 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42303 {
42304 PyThreadState* __tstate = wxPyBeginAllowThreads();
42305 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42306 wxPyEndAllowThreads(__tstate);
42307 if (PyErr_Occurred()) SWIG_fail;
42308 }
42309 {
42310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42311 }
42312 return resultobj;
42313 fail:
42314 return NULL;
42315 }
42316
42317
42318 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42319 PyObject *resultobj = 0;
42320 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42321 wxMenu *arg2 = (wxMenu *) 0 ;
42322 void *argp1 = 0 ;
42323 int res1 = 0 ;
42324 void *argp2 = 0 ;
42325 int res2 = 0 ;
42326 PyObject * obj0 = 0 ;
42327 PyObject * obj1 = 0 ;
42328 char * kwnames[] = {
42329 (char *) "self",(char *) "menu", NULL
42330 };
42331
42332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42334 if (!SWIG_IsOK(res1)) {
42335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42336 }
42337 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42338 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42339 if (!SWIG_IsOK(res2)) {
42340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42341 }
42342 arg2 = reinterpret_cast< wxMenu * >(argp2);
42343 {
42344 PyThreadState* __tstate = wxPyBeginAllowThreads();
42345 (arg1)->SetSubMenu(arg2);
42346 wxPyEndAllowThreads(__tstate);
42347 if (PyErr_Occurred()) SWIG_fail;
42348 }
42349 resultobj = SWIG_Py_Void();
42350 return resultobj;
42351 fail:
42352 return NULL;
42353 }
42354
42355
42356 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42357 PyObject *resultobj = 0;
42358 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42359 wxMenu *result = 0 ;
42360 void *argp1 = 0 ;
42361 int res1 = 0 ;
42362 PyObject *swig_obj[1] ;
42363
42364 if (!args) SWIG_fail;
42365 swig_obj[0] = args;
42366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42367 if (!SWIG_IsOK(res1)) {
42368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42369 }
42370 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42371 {
42372 PyThreadState* __tstate = wxPyBeginAllowThreads();
42373 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42374 wxPyEndAllowThreads(__tstate);
42375 if (PyErr_Occurred()) SWIG_fail;
42376 }
42377 {
42378 resultobj = wxPyMake_wxObject(result, 0);
42379 }
42380 return resultobj;
42381 fail:
42382 return NULL;
42383 }
42384
42385
42386 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42387 PyObject *resultobj = 0;
42388 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42389 bool arg2 = (bool) true ;
42390 void *argp1 = 0 ;
42391 int res1 = 0 ;
42392 bool val2 ;
42393 int ecode2 = 0 ;
42394 PyObject * obj0 = 0 ;
42395 PyObject * obj1 = 0 ;
42396 char * kwnames[] = {
42397 (char *) "self",(char *) "enable", NULL
42398 };
42399
42400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42402 if (!SWIG_IsOK(res1)) {
42403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42404 }
42405 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42406 if (obj1) {
42407 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42408 if (!SWIG_IsOK(ecode2)) {
42409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42410 }
42411 arg2 = static_cast< bool >(val2);
42412 }
42413 {
42414 PyThreadState* __tstate = wxPyBeginAllowThreads();
42415 (arg1)->Enable(arg2);
42416 wxPyEndAllowThreads(__tstate);
42417 if (PyErr_Occurred()) SWIG_fail;
42418 }
42419 resultobj = SWIG_Py_Void();
42420 return resultobj;
42421 fail:
42422 return NULL;
42423 }
42424
42425
42426 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42427 PyObject *resultobj = 0;
42428 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42429 bool result;
42430 void *argp1 = 0 ;
42431 int res1 = 0 ;
42432 PyObject *swig_obj[1] ;
42433
42434 if (!args) SWIG_fail;
42435 swig_obj[0] = args;
42436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42437 if (!SWIG_IsOK(res1)) {
42438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42439 }
42440 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42441 {
42442 PyThreadState* __tstate = wxPyBeginAllowThreads();
42443 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42444 wxPyEndAllowThreads(__tstate);
42445 if (PyErr_Occurred()) SWIG_fail;
42446 }
42447 {
42448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42449 }
42450 return resultobj;
42451 fail:
42452 return NULL;
42453 }
42454
42455
42456 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42457 PyObject *resultobj = 0;
42458 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42459 bool arg2 = (bool) true ;
42460 void *argp1 = 0 ;
42461 int res1 = 0 ;
42462 bool val2 ;
42463 int ecode2 = 0 ;
42464 PyObject * obj0 = 0 ;
42465 PyObject * obj1 = 0 ;
42466 char * kwnames[] = {
42467 (char *) "self",(char *) "check", NULL
42468 };
42469
42470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42472 if (!SWIG_IsOK(res1)) {
42473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42474 }
42475 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42476 if (obj1) {
42477 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42478 if (!SWIG_IsOK(ecode2)) {
42479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42480 }
42481 arg2 = static_cast< bool >(val2);
42482 }
42483 {
42484 PyThreadState* __tstate = wxPyBeginAllowThreads();
42485 (arg1)->Check(arg2);
42486 wxPyEndAllowThreads(__tstate);
42487 if (PyErr_Occurred()) SWIG_fail;
42488 }
42489 resultobj = SWIG_Py_Void();
42490 return resultobj;
42491 fail:
42492 return NULL;
42493 }
42494
42495
42496 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42497 PyObject *resultobj = 0;
42498 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42499 bool result;
42500 void *argp1 = 0 ;
42501 int res1 = 0 ;
42502 PyObject *swig_obj[1] ;
42503
42504 if (!args) SWIG_fail;
42505 swig_obj[0] = args;
42506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42507 if (!SWIG_IsOK(res1)) {
42508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42509 }
42510 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42511 {
42512 PyThreadState* __tstate = wxPyBeginAllowThreads();
42513 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42514 wxPyEndAllowThreads(__tstate);
42515 if (PyErr_Occurred()) SWIG_fail;
42516 }
42517 {
42518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42519 }
42520 return resultobj;
42521 fail:
42522 return NULL;
42523 }
42524
42525
42526 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42527 PyObject *resultobj = 0;
42528 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42529 void *argp1 = 0 ;
42530 int res1 = 0 ;
42531 PyObject *swig_obj[1] ;
42532
42533 if (!args) SWIG_fail;
42534 swig_obj[0] = args;
42535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42536 if (!SWIG_IsOK(res1)) {
42537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42538 }
42539 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42540 {
42541 PyThreadState* __tstate = wxPyBeginAllowThreads();
42542 (arg1)->Toggle();
42543 wxPyEndAllowThreads(__tstate);
42544 if (PyErr_Occurred()) SWIG_fail;
42545 }
42546 resultobj = SWIG_Py_Void();
42547 return resultobj;
42548 fail:
42549 return NULL;
42550 }
42551
42552
42553 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42554 PyObject *resultobj = 0;
42555 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42556 wxString *arg2 = 0 ;
42557 void *argp1 = 0 ;
42558 int res1 = 0 ;
42559 bool temp2 = false ;
42560 PyObject * obj0 = 0 ;
42561 PyObject * obj1 = 0 ;
42562 char * kwnames[] = {
42563 (char *) "self",(char *) "str", NULL
42564 };
42565
42566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42568 if (!SWIG_IsOK(res1)) {
42569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42570 }
42571 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42572 {
42573 arg2 = wxString_in_helper(obj1);
42574 if (arg2 == NULL) SWIG_fail;
42575 temp2 = true;
42576 }
42577 {
42578 PyThreadState* __tstate = wxPyBeginAllowThreads();
42579 (arg1)->SetHelp((wxString const &)*arg2);
42580 wxPyEndAllowThreads(__tstate);
42581 if (PyErr_Occurred()) SWIG_fail;
42582 }
42583 resultobj = SWIG_Py_Void();
42584 {
42585 if (temp2)
42586 delete arg2;
42587 }
42588 return resultobj;
42589 fail:
42590 {
42591 if (temp2)
42592 delete arg2;
42593 }
42594 return NULL;
42595 }
42596
42597
42598 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42599 PyObject *resultobj = 0;
42600 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42601 wxString *result = 0 ;
42602 void *argp1 = 0 ;
42603 int res1 = 0 ;
42604 PyObject *swig_obj[1] ;
42605
42606 if (!args) SWIG_fail;
42607 swig_obj[0] = args;
42608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42609 if (!SWIG_IsOK(res1)) {
42610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42611 }
42612 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42613 {
42614 PyThreadState* __tstate = wxPyBeginAllowThreads();
42615 {
42616 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42617 result = (wxString *) &_result_ref;
42618 }
42619 wxPyEndAllowThreads(__tstate);
42620 if (PyErr_Occurred()) SWIG_fail;
42621 }
42622 {
42623 #if wxUSE_UNICODE
42624 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42625 #else
42626 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42627 #endif
42628 }
42629 return resultobj;
42630 fail:
42631 return NULL;
42632 }
42633
42634
42635 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42636 PyObject *resultobj = 0;
42637 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42638 wxAcceleratorEntry *result = 0 ;
42639 void *argp1 = 0 ;
42640 int res1 = 0 ;
42641 PyObject *swig_obj[1] ;
42642
42643 if (!args) SWIG_fail;
42644 swig_obj[0] = args;
42645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42646 if (!SWIG_IsOK(res1)) {
42647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42648 }
42649 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42650 {
42651 PyThreadState* __tstate = wxPyBeginAllowThreads();
42652 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42653 wxPyEndAllowThreads(__tstate);
42654 if (PyErr_Occurred()) SWIG_fail;
42655 }
42656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42657 return resultobj;
42658 fail:
42659 return NULL;
42660 }
42661
42662
42663 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42664 PyObject *resultobj = 0;
42665 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42666 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42667 void *argp1 = 0 ;
42668 int res1 = 0 ;
42669 void *argp2 = 0 ;
42670 int res2 = 0 ;
42671 PyObject * obj0 = 0 ;
42672 PyObject * obj1 = 0 ;
42673 char * kwnames[] = {
42674 (char *) "self",(char *) "accel", NULL
42675 };
42676
42677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42679 if (!SWIG_IsOK(res1)) {
42680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42681 }
42682 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42683 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42684 if (!SWIG_IsOK(res2)) {
42685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42686 }
42687 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42688 {
42689 PyThreadState* __tstate = wxPyBeginAllowThreads();
42690 (arg1)->SetAccel(arg2);
42691 wxPyEndAllowThreads(__tstate);
42692 if (PyErr_Occurred()) SWIG_fail;
42693 }
42694 resultobj = SWIG_Py_Void();
42695 return resultobj;
42696 fail:
42697 return NULL;
42698 }
42699
42700
42701 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42702 PyObject *resultobj = 0;
42703 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42704 wxBitmap *arg2 = 0 ;
42705 void *argp1 = 0 ;
42706 int res1 = 0 ;
42707 void *argp2 = 0 ;
42708 int res2 = 0 ;
42709 PyObject * obj0 = 0 ;
42710 PyObject * obj1 = 0 ;
42711 char * kwnames[] = {
42712 (char *) "self",(char *) "bitmap", NULL
42713 };
42714
42715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42717 if (!SWIG_IsOK(res1)) {
42718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42719 }
42720 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42721 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42722 if (!SWIG_IsOK(res2)) {
42723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42724 }
42725 if (!argp2) {
42726 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42727 }
42728 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42729 {
42730 PyThreadState* __tstate = wxPyBeginAllowThreads();
42731 (arg1)->SetBitmap((wxBitmap const &)*arg2);
42732 wxPyEndAllowThreads(__tstate);
42733 if (PyErr_Occurred()) SWIG_fail;
42734 }
42735 resultobj = SWIG_Py_Void();
42736 return resultobj;
42737 fail:
42738 return NULL;
42739 }
42740
42741
42742 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42743 PyObject *resultobj = 0;
42744 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42745 wxBitmap *result = 0 ;
42746 void *argp1 = 0 ;
42747 int res1 = 0 ;
42748 PyObject *swig_obj[1] ;
42749
42750 if (!args) SWIG_fail;
42751 swig_obj[0] = args;
42752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42753 if (!SWIG_IsOK(res1)) {
42754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42755 }
42756 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42757 {
42758 PyThreadState* __tstate = wxPyBeginAllowThreads();
42759 {
42760 wxBitmap const &_result_ref = (arg1)->GetBitmap();
42761 result = (wxBitmap *) &_result_ref;
42762 }
42763 wxPyEndAllowThreads(__tstate);
42764 if (PyErr_Occurred()) SWIG_fail;
42765 }
42766 {
42767 wxBitmap* resultptr = new wxBitmap(*result);
42768 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
42769 }
42770 return resultobj;
42771 fail:
42772 return NULL;
42773 }
42774
42775
42776 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42777 PyObject *resultobj = 0;
42778 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42779 wxFont *arg2 = 0 ;
42780 void *argp1 = 0 ;
42781 int res1 = 0 ;
42782 void *argp2 = 0 ;
42783 int res2 = 0 ;
42784 PyObject * obj0 = 0 ;
42785 PyObject * obj1 = 0 ;
42786 char * kwnames[] = {
42787 (char *) "self",(char *) "font", NULL
42788 };
42789
42790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
42791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42792 if (!SWIG_IsOK(res1)) {
42793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42794 }
42795 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42796 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
42797 if (!SWIG_IsOK(res2)) {
42798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42799 }
42800 if (!argp2) {
42801 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42802 }
42803 arg2 = reinterpret_cast< wxFont * >(argp2);
42804 {
42805 PyThreadState* __tstate = wxPyBeginAllowThreads();
42806 (arg1)->SetFont((wxFont const &)*arg2);
42807 wxPyEndAllowThreads(__tstate);
42808 if (PyErr_Occurred()) SWIG_fail;
42809 }
42810 resultobj = SWIG_Py_Void();
42811 return resultobj;
42812 fail:
42813 return NULL;
42814 }
42815
42816
42817 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42818 PyObject *resultobj = 0;
42819 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42820 wxFont result;
42821 void *argp1 = 0 ;
42822 int res1 = 0 ;
42823 PyObject *swig_obj[1] ;
42824
42825 if (!args) SWIG_fail;
42826 swig_obj[0] = args;
42827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42828 if (!SWIG_IsOK(res1)) {
42829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42830 }
42831 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42832 {
42833 PyThreadState* __tstate = wxPyBeginAllowThreads();
42834 result = (arg1)->GetFont();
42835 wxPyEndAllowThreads(__tstate);
42836 if (PyErr_Occurred()) SWIG_fail;
42837 }
42838 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
42839 return resultobj;
42840 fail:
42841 return NULL;
42842 }
42843
42844
42845 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42846 PyObject *resultobj = 0;
42847 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42848 wxColour *arg2 = 0 ;
42849 void *argp1 = 0 ;
42850 int res1 = 0 ;
42851 wxColour temp2 ;
42852 PyObject * obj0 = 0 ;
42853 PyObject * obj1 = 0 ;
42854 char * kwnames[] = {
42855 (char *) "self",(char *) "colText", NULL
42856 };
42857
42858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
42859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42860 if (!SWIG_IsOK(res1)) {
42861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42862 }
42863 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42864 {
42865 arg2 = &temp2;
42866 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
42867 }
42868 {
42869 PyThreadState* __tstate = wxPyBeginAllowThreads();
42870 (arg1)->SetTextColour((wxColour const &)*arg2);
42871 wxPyEndAllowThreads(__tstate);
42872 if (PyErr_Occurred()) SWIG_fail;
42873 }
42874 resultobj = SWIG_Py_Void();
42875 return resultobj;
42876 fail:
42877 return NULL;
42878 }
42879
42880
42881 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42882 PyObject *resultobj = 0;
42883 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42884 wxColour result;
42885 void *argp1 = 0 ;
42886 int res1 = 0 ;
42887 PyObject *swig_obj[1] ;
42888
42889 if (!args) SWIG_fail;
42890 swig_obj[0] = args;
42891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42892 if (!SWIG_IsOK(res1)) {
42893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42894 }
42895 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42896 {
42897 PyThreadState* __tstate = wxPyBeginAllowThreads();
42898 result = (arg1)->GetTextColour();
42899 wxPyEndAllowThreads(__tstate);
42900 if (PyErr_Occurred()) SWIG_fail;
42901 }
42902 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
42903 return resultobj;
42904 fail:
42905 return NULL;
42906 }
42907
42908
42909 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42910 PyObject *resultobj = 0;
42911 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42912 wxColour *arg2 = 0 ;
42913 void *argp1 = 0 ;
42914 int res1 = 0 ;
42915 wxColour temp2 ;
42916 PyObject * obj0 = 0 ;
42917 PyObject * obj1 = 0 ;
42918 char * kwnames[] = {
42919 (char *) "self",(char *) "colBack", NULL
42920 };
42921
42922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
42923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42924 if (!SWIG_IsOK(res1)) {
42925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42926 }
42927 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42928 {
42929 arg2 = &temp2;
42930 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
42931 }
42932 {
42933 PyThreadState* __tstate = wxPyBeginAllowThreads();
42934 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
42935 wxPyEndAllowThreads(__tstate);
42936 if (PyErr_Occurred()) SWIG_fail;
42937 }
42938 resultobj = SWIG_Py_Void();
42939 return resultobj;
42940 fail:
42941 return NULL;
42942 }
42943
42944
42945 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42946 PyObject *resultobj = 0;
42947 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42948 wxColour result;
42949 void *argp1 = 0 ;
42950 int res1 = 0 ;
42951 PyObject *swig_obj[1] ;
42952
42953 if (!args) SWIG_fail;
42954 swig_obj[0] = args;
42955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42956 if (!SWIG_IsOK(res1)) {
42957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42958 }
42959 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42960 {
42961 PyThreadState* __tstate = wxPyBeginAllowThreads();
42962 result = (arg1)->GetBackgroundColour();
42963 wxPyEndAllowThreads(__tstate);
42964 if (PyErr_Occurred()) SWIG_fail;
42965 }
42966 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
42967 return resultobj;
42968 fail:
42969 return NULL;
42970 }
42971
42972
42973 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42974 PyObject *resultobj = 0;
42975 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42976 wxBitmap *arg2 = 0 ;
42977 wxBitmap const &arg3_defvalue = wxNullBitmap ;
42978 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
42979 void *argp1 = 0 ;
42980 int res1 = 0 ;
42981 void *argp2 = 0 ;
42982 int res2 = 0 ;
42983 void *argp3 = 0 ;
42984 int res3 = 0 ;
42985 PyObject * obj0 = 0 ;
42986 PyObject * obj1 = 0 ;
42987 PyObject * obj2 = 0 ;
42988 char * kwnames[] = {
42989 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
42990 };
42991
42992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42994 if (!SWIG_IsOK(res1)) {
42995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42996 }
42997 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42998 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42999 if (!SWIG_IsOK(res2)) {
43000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43001 }
43002 if (!argp2) {
43003 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43004 }
43005 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43006 if (obj2) {
43007 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43008 if (!SWIG_IsOK(res3)) {
43009 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43010 }
43011 if (!argp3) {
43012 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43013 }
43014 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43015 }
43016 {
43017 PyThreadState* __tstate = wxPyBeginAllowThreads();
43018 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43019 wxPyEndAllowThreads(__tstate);
43020 if (PyErr_Occurred()) SWIG_fail;
43021 }
43022 resultobj = SWIG_Py_Void();
43023 return resultobj;
43024 fail:
43025 return NULL;
43026 }
43027
43028
43029 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43030 PyObject *resultobj = 0;
43031 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43032 wxBitmap *arg2 = 0 ;
43033 void *argp1 = 0 ;
43034 int res1 = 0 ;
43035 void *argp2 = 0 ;
43036 int res2 = 0 ;
43037 PyObject * obj0 = 0 ;
43038 PyObject * obj1 = 0 ;
43039 char * kwnames[] = {
43040 (char *) "self",(char *) "bmpDisabled", NULL
43041 };
43042
43043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43045 if (!SWIG_IsOK(res1)) {
43046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43047 }
43048 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43049 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43050 if (!SWIG_IsOK(res2)) {
43051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43052 }
43053 if (!argp2) {
43054 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43055 }
43056 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43057 {
43058 PyThreadState* __tstate = wxPyBeginAllowThreads();
43059 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43060 wxPyEndAllowThreads(__tstate);
43061 if (PyErr_Occurred()) SWIG_fail;
43062 }
43063 resultobj = SWIG_Py_Void();
43064 return resultobj;
43065 fail:
43066 return NULL;
43067 }
43068
43069
43070 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43071 PyObject *resultobj = 0;
43072 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43073 wxBitmap *result = 0 ;
43074 void *argp1 = 0 ;
43075 int res1 = 0 ;
43076 PyObject *swig_obj[1] ;
43077
43078 if (!args) SWIG_fail;
43079 swig_obj[0] = args;
43080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43081 if (!SWIG_IsOK(res1)) {
43082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43083 }
43084 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43085 {
43086 PyThreadState* __tstate = wxPyBeginAllowThreads();
43087 {
43088 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43089 result = (wxBitmap *) &_result_ref;
43090 }
43091 wxPyEndAllowThreads(__tstate);
43092 if (PyErr_Occurred()) SWIG_fail;
43093 }
43094 {
43095 wxBitmap* resultptr = new wxBitmap(*result);
43096 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43097 }
43098 return resultobj;
43099 fail:
43100 return NULL;
43101 }
43102
43103
43104 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43105 PyObject *resultobj = 0;
43106 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43107 int arg2 ;
43108 void *argp1 = 0 ;
43109 int res1 = 0 ;
43110 int val2 ;
43111 int ecode2 = 0 ;
43112 PyObject * obj0 = 0 ;
43113 PyObject * obj1 = 0 ;
43114 char * kwnames[] = {
43115 (char *) "self",(char *) "nWidth", NULL
43116 };
43117
43118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43120 if (!SWIG_IsOK(res1)) {
43121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43122 }
43123 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43124 ecode2 = SWIG_AsVal_int(obj1, &val2);
43125 if (!SWIG_IsOK(ecode2)) {
43126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43127 }
43128 arg2 = static_cast< int >(val2);
43129 {
43130 PyThreadState* __tstate = wxPyBeginAllowThreads();
43131 (arg1)->SetMarginWidth(arg2);
43132 wxPyEndAllowThreads(__tstate);
43133 if (PyErr_Occurred()) SWIG_fail;
43134 }
43135 resultobj = SWIG_Py_Void();
43136 return resultobj;
43137 fail:
43138 return NULL;
43139 }
43140
43141
43142 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43143 PyObject *resultobj = 0;
43144 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43145 int result;
43146 void *argp1 = 0 ;
43147 int res1 = 0 ;
43148 PyObject *swig_obj[1] ;
43149
43150 if (!args) SWIG_fail;
43151 swig_obj[0] = args;
43152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43153 if (!SWIG_IsOK(res1)) {
43154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43155 }
43156 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43157 {
43158 PyThreadState* __tstate = wxPyBeginAllowThreads();
43159 result = (int)(arg1)->GetMarginWidth();
43160 wxPyEndAllowThreads(__tstate);
43161 if (PyErr_Occurred()) SWIG_fail;
43162 }
43163 resultobj = SWIG_From_int(static_cast< int >(result));
43164 return resultobj;
43165 fail:
43166 return NULL;
43167 }
43168
43169
43170 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43171 PyObject *resultobj = 0;
43172 int result;
43173
43174 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43175 {
43176 PyThreadState* __tstate = wxPyBeginAllowThreads();
43177 result = (int)wxMenuItem::GetDefaultMarginWidth();
43178 wxPyEndAllowThreads(__tstate);
43179 if (PyErr_Occurred()) SWIG_fail;
43180 }
43181 resultobj = SWIG_From_int(static_cast< int >(result));
43182 return resultobj;
43183 fail:
43184 return NULL;
43185 }
43186
43187
43188 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43189 PyObject *resultobj = 0;
43190 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43191 bool result;
43192 void *argp1 = 0 ;
43193 int res1 = 0 ;
43194 PyObject *swig_obj[1] ;
43195
43196 if (!args) SWIG_fail;
43197 swig_obj[0] = args;
43198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43199 if (!SWIG_IsOK(res1)) {
43200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43201 }
43202 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43203 {
43204 PyThreadState* __tstate = wxPyBeginAllowThreads();
43205 result = (bool)(arg1)->IsOwnerDrawn();
43206 wxPyEndAllowThreads(__tstate);
43207 if (PyErr_Occurred()) SWIG_fail;
43208 }
43209 {
43210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43211 }
43212 return resultobj;
43213 fail:
43214 return NULL;
43215 }
43216
43217
43218 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43219 PyObject *resultobj = 0;
43220 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43221 bool arg2 = (bool) true ;
43222 void *argp1 = 0 ;
43223 int res1 = 0 ;
43224 bool val2 ;
43225 int ecode2 = 0 ;
43226 PyObject * obj0 = 0 ;
43227 PyObject * obj1 = 0 ;
43228 char * kwnames[] = {
43229 (char *) "self",(char *) "ownerDrawn", NULL
43230 };
43231
43232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43234 if (!SWIG_IsOK(res1)) {
43235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43236 }
43237 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43238 if (obj1) {
43239 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43240 if (!SWIG_IsOK(ecode2)) {
43241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43242 }
43243 arg2 = static_cast< bool >(val2);
43244 }
43245 {
43246 PyThreadState* __tstate = wxPyBeginAllowThreads();
43247 (arg1)->SetOwnerDrawn(arg2);
43248 wxPyEndAllowThreads(__tstate);
43249 if (PyErr_Occurred()) SWIG_fail;
43250 }
43251 resultobj = SWIG_Py_Void();
43252 return resultobj;
43253 fail:
43254 return NULL;
43255 }
43256
43257
43258 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43259 PyObject *resultobj = 0;
43260 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43261 void *argp1 = 0 ;
43262 int res1 = 0 ;
43263 PyObject *swig_obj[1] ;
43264
43265 if (!args) SWIG_fail;
43266 swig_obj[0] = args;
43267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43268 if (!SWIG_IsOK(res1)) {
43269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43270 }
43271 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43272 {
43273 PyThreadState* __tstate = wxPyBeginAllowThreads();
43274 (arg1)->ResetOwnerDrawn();
43275 wxPyEndAllowThreads(__tstate);
43276 if (PyErr_Occurred()) SWIG_fail;
43277 }
43278 resultobj = SWIG_Py_Void();
43279 return resultobj;
43280 fail:
43281 return NULL;
43282 }
43283
43284
43285 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43286 PyObject *obj;
43287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43288 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43289 return SWIG_Py_Void();
43290 }
43291
43292 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43293 return SWIG_Python_InitShadowInstance(args);
43294 }
43295
43296 SWIGINTERN int ControlNameStr_set(PyObject *) {
43297 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43298 return 1;
43299 }
43300
43301
43302 SWIGINTERN PyObject *ControlNameStr_get(void) {
43303 PyObject *pyobj = 0;
43304
43305 {
43306 #if wxUSE_UNICODE
43307 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43308 #else
43309 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43310 #endif
43311 }
43312 return pyobj;
43313 }
43314
43315
43316 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43317 PyObject *resultobj = 0;
43318 wxWindow *arg1 = (wxWindow *) 0 ;
43319 int arg2 = (int) -1 ;
43320 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43321 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43322 wxSize const &arg4_defvalue = wxDefaultSize ;
43323 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43324 long arg5 = (long) 0 ;
43325 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43326 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43327 wxString const &arg7_defvalue = wxPyControlNameStr ;
43328 wxString *arg7 = (wxString *) &arg7_defvalue ;
43329 wxControl *result = 0 ;
43330 void *argp1 = 0 ;
43331 int res1 = 0 ;
43332 int val2 ;
43333 int ecode2 = 0 ;
43334 wxPoint temp3 ;
43335 wxSize temp4 ;
43336 long val5 ;
43337 int ecode5 = 0 ;
43338 void *argp6 = 0 ;
43339 int res6 = 0 ;
43340 bool temp7 = false ;
43341 PyObject * obj0 = 0 ;
43342 PyObject * obj1 = 0 ;
43343 PyObject * obj2 = 0 ;
43344 PyObject * obj3 = 0 ;
43345 PyObject * obj4 = 0 ;
43346 PyObject * obj5 = 0 ;
43347 PyObject * obj6 = 0 ;
43348 char * kwnames[] = {
43349 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43350 };
43351
43352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43354 if (!SWIG_IsOK(res1)) {
43355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43356 }
43357 arg1 = reinterpret_cast< wxWindow * >(argp1);
43358 if (obj1) {
43359 ecode2 = SWIG_AsVal_int(obj1, &val2);
43360 if (!SWIG_IsOK(ecode2)) {
43361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43362 }
43363 arg2 = static_cast< int >(val2);
43364 }
43365 if (obj2) {
43366 {
43367 arg3 = &temp3;
43368 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43369 }
43370 }
43371 if (obj3) {
43372 {
43373 arg4 = &temp4;
43374 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43375 }
43376 }
43377 if (obj4) {
43378 ecode5 = SWIG_AsVal_long(obj4, &val5);
43379 if (!SWIG_IsOK(ecode5)) {
43380 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43381 }
43382 arg5 = static_cast< long >(val5);
43383 }
43384 if (obj5) {
43385 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43386 if (!SWIG_IsOK(res6)) {
43387 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43388 }
43389 if (!argp6) {
43390 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43391 }
43392 arg6 = reinterpret_cast< wxValidator * >(argp6);
43393 }
43394 if (obj6) {
43395 {
43396 arg7 = wxString_in_helper(obj6);
43397 if (arg7 == NULL) SWIG_fail;
43398 temp7 = true;
43399 }
43400 }
43401 {
43402 if (!wxPyCheckForApp()) SWIG_fail;
43403 PyThreadState* __tstate = wxPyBeginAllowThreads();
43404 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43405 wxPyEndAllowThreads(__tstate);
43406 if (PyErr_Occurred()) SWIG_fail;
43407 }
43408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43409 {
43410 if (temp7)
43411 delete arg7;
43412 }
43413 return resultobj;
43414 fail:
43415 {
43416 if (temp7)
43417 delete arg7;
43418 }
43419 return NULL;
43420 }
43421
43422
43423 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43424 PyObject *resultobj = 0;
43425 wxControl *result = 0 ;
43426
43427 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43428 {
43429 if (!wxPyCheckForApp()) SWIG_fail;
43430 PyThreadState* __tstate = wxPyBeginAllowThreads();
43431 result = (wxControl *)new wxControl();
43432 wxPyEndAllowThreads(__tstate);
43433 if (PyErr_Occurred()) SWIG_fail;
43434 }
43435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43436 return resultobj;
43437 fail:
43438 return NULL;
43439 }
43440
43441
43442 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43443 PyObject *resultobj = 0;
43444 wxControl *arg1 = (wxControl *) 0 ;
43445 wxWindow *arg2 = (wxWindow *) 0 ;
43446 int arg3 = (int) -1 ;
43447 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43448 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43449 wxSize const &arg5_defvalue = wxDefaultSize ;
43450 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43451 long arg6 = (long) 0 ;
43452 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43453 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43454 wxString const &arg8_defvalue = wxPyControlNameStr ;
43455 wxString *arg8 = (wxString *) &arg8_defvalue ;
43456 bool result;
43457 void *argp1 = 0 ;
43458 int res1 = 0 ;
43459 void *argp2 = 0 ;
43460 int res2 = 0 ;
43461 int val3 ;
43462 int ecode3 = 0 ;
43463 wxPoint temp4 ;
43464 wxSize temp5 ;
43465 long val6 ;
43466 int ecode6 = 0 ;
43467 void *argp7 = 0 ;
43468 int res7 = 0 ;
43469 bool temp8 = false ;
43470 PyObject * obj0 = 0 ;
43471 PyObject * obj1 = 0 ;
43472 PyObject * obj2 = 0 ;
43473 PyObject * obj3 = 0 ;
43474 PyObject * obj4 = 0 ;
43475 PyObject * obj5 = 0 ;
43476 PyObject * obj6 = 0 ;
43477 PyObject * obj7 = 0 ;
43478 char * kwnames[] = {
43479 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43480 };
43481
43482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43484 if (!SWIG_IsOK(res1)) {
43485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43486 }
43487 arg1 = reinterpret_cast< wxControl * >(argp1);
43488 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43489 if (!SWIG_IsOK(res2)) {
43490 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43491 }
43492 arg2 = reinterpret_cast< wxWindow * >(argp2);
43493 if (obj2) {
43494 ecode3 = SWIG_AsVal_int(obj2, &val3);
43495 if (!SWIG_IsOK(ecode3)) {
43496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43497 }
43498 arg3 = static_cast< int >(val3);
43499 }
43500 if (obj3) {
43501 {
43502 arg4 = &temp4;
43503 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43504 }
43505 }
43506 if (obj4) {
43507 {
43508 arg5 = &temp5;
43509 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43510 }
43511 }
43512 if (obj5) {
43513 ecode6 = SWIG_AsVal_long(obj5, &val6);
43514 if (!SWIG_IsOK(ecode6)) {
43515 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43516 }
43517 arg6 = static_cast< long >(val6);
43518 }
43519 if (obj6) {
43520 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43521 if (!SWIG_IsOK(res7)) {
43522 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43523 }
43524 if (!argp7) {
43525 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43526 }
43527 arg7 = reinterpret_cast< wxValidator * >(argp7);
43528 }
43529 if (obj7) {
43530 {
43531 arg8 = wxString_in_helper(obj7);
43532 if (arg8 == NULL) SWIG_fail;
43533 temp8 = true;
43534 }
43535 }
43536 {
43537 PyThreadState* __tstate = wxPyBeginAllowThreads();
43538 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43539 wxPyEndAllowThreads(__tstate);
43540 if (PyErr_Occurred()) SWIG_fail;
43541 }
43542 {
43543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43544 }
43545 {
43546 if (temp8)
43547 delete arg8;
43548 }
43549 return resultobj;
43550 fail:
43551 {
43552 if (temp8)
43553 delete arg8;
43554 }
43555 return NULL;
43556 }
43557
43558
43559 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43560 PyObject *resultobj = 0;
43561 wxControl *arg1 = (wxControl *) 0 ;
43562 wxCommandEvent *arg2 = 0 ;
43563 void *argp1 = 0 ;
43564 int res1 = 0 ;
43565 void *argp2 = 0 ;
43566 int res2 = 0 ;
43567 PyObject * obj0 = 0 ;
43568 PyObject * obj1 = 0 ;
43569 char * kwnames[] = {
43570 (char *) "self",(char *) "event", NULL
43571 };
43572
43573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43575 if (!SWIG_IsOK(res1)) {
43576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43577 }
43578 arg1 = reinterpret_cast< wxControl * >(argp1);
43579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43580 if (!SWIG_IsOK(res2)) {
43581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43582 }
43583 if (!argp2) {
43584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43585 }
43586 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43587 {
43588 PyThreadState* __tstate = wxPyBeginAllowThreads();
43589 (arg1)->Command(*arg2);
43590 wxPyEndAllowThreads(__tstate);
43591 if (PyErr_Occurred()) SWIG_fail;
43592 }
43593 resultobj = SWIG_Py_Void();
43594 return resultobj;
43595 fail:
43596 return NULL;
43597 }
43598
43599
43600 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43601 PyObject *resultobj = 0;
43602 wxControl *arg1 = (wxControl *) 0 ;
43603 wxString result;
43604 void *argp1 = 0 ;
43605 int res1 = 0 ;
43606 PyObject *swig_obj[1] ;
43607
43608 if (!args) SWIG_fail;
43609 swig_obj[0] = args;
43610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43611 if (!SWIG_IsOK(res1)) {
43612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43613 }
43614 arg1 = reinterpret_cast< wxControl * >(argp1);
43615 {
43616 PyThreadState* __tstate = wxPyBeginAllowThreads();
43617 result = (arg1)->GetLabel();
43618 wxPyEndAllowThreads(__tstate);
43619 if (PyErr_Occurred()) SWIG_fail;
43620 }
43621 {
43622 #if wxUSE_UNICODE
43623 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43624 #else
43625 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43626 #endif
43627 }
43628 return resultobj;
43629 fail:
43630 return NULL;
43631 }
43632
43633
43634 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43635 PyObject *resultobj = 0;
43636 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43637 SwigValueWrapper<wxVisualAttributes > result;
43638 int val1 ;
43639 int ecode1 = 0 ;
43640 PyObject * obj0 = 0 ;
43641 char * kwnames[] = {
43642 (char *) "variant", NULL
43643 };
43644
43645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43646 if (obj0) {
43647 ecode1 = SWIG_AsVal_int(obj0, &val1);
43648 if (!SWIG_IsOK(ecode1)) {
43649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43650 }
43651 arg1 = static_cast< wxWindowVariant >(val1);
43652 }
43653 {
43654 if (!wxPyCheckForApp()) SWIG_fail;
43655 PyThreadState* __tstate = wxPyBeginAllowThreads();
43656 result = wxControl::GetClassDefaultAttributes(arg1);
43657 wxPyEndAllowThreads(__tstate);
43658 if (PyErr_Occurred()) SWIG_fail;
43659 }
43660 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43661 return resultobj;
43662 fail:
43663 return NULL;
43664 }
43665
43666
43667 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43668 PyObject *obj;
43669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43670 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43671 return SWIG_Py_Void();
43672 }
43673
43674 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43675 return SWIG_Python_InitShadowInstance(args);
43676 }
43677
43678 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43679 PyObject *resultobj = 0;
43680 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43681 wxString *arg2 = 0 ;
43682 PyObject *arg3 = (PyObject *) NULL ;
43683 int result;
43684 void *argp1 = 0 ;
43685 int res1 = 0 ;
43686 bool temp2 = false ;
43687 PyObject * obj0 = 0 ;
43688 PyObject * obj1 = 0 ;
43689 PyObject * obj2 = 0 ;
43690 char * kwnames[] = {
43691 (char *) "self",(char *) "item",(char *) "clientData", NULL
43692 };
43693
43694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43696 if (!SWIG_IsOK(res1)) {
43697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43698 }
43699 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43700 {
43701 arg2 = wxString_in_helper(obj1);
43702 if (arg2 == NULL) SWIG_fail;
43703 temp2 = true;
43704 }
43705 if (obj2) {
43706 arg3 = obj2;
43707 }
43708 {
43709 PyThreadState* __tstate = wxPyBeginAllowThreads();
43710 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43711 wxPyEndAllowThreads(__tstate);
43712 if (PyErr_Occurred()) SWIG_fail;
43713 }
43714 resultobj = SWIG_From_int(static_cast< int >(result));
43715 {
43716 if (temp2)
43717 delete arg2;
43718 }
43719 return resultobj;
43720 fail:
43721 {
43722 if (temp2)
43723 delete arg2;
43724 }
43725 return NULL;
43726 }
43727
43728
43729 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43730 PyObject *resultobj = 0;
43731 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43732 wxArrayString *arg2 = 0 ;
43733 void *argp1 = 0 ;
43734 int res1 = 0 ;
43735 bool temp2 = false ;
43736 PyObject * obj0 = 0 ;
43737 PyObject * obj1 = 0 ;
43738 char * kwnames[] = {
43739 (char *) "self",(char *) "strings", NULL
43740 };
43741
43742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
43743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43744 if (!SWIG_IsOK(res1)) {
43745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43746 }
43747 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43748 {
43749 if (! PySequence_Check(obj1)) {
43750 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
43751 SWIG_fail;
43752 }
43753 arg2 = new wxArrayString;
43754 temp2 = true;
43755 int i, len=PySequence_Length(obj1);
43756 for (i=0; i<len; i++) {
43757 PyObject* item = PySequence_GetItem(obj1, i);
43758 wxString* s = wxString_in_helper(item);
43759 if (PyErr_Occurred()) SWIG_fail;
43760 arg2->Add(*s);
43761 delete s;
43762 Py_DECREF(item);
43763 }
43764 }
43765 {
43766 PyThreadState* __tstate = wxPyBeginAllowThreads();
43767 (arg1)->Append((wxArrayString const &)*arg2);
43768 wxPyEndAllowThreads(__tstate);
43769 if (PyErr_Occurred()) SWIG_fail;
43770 }
43771 resultobj = SWIG_Py_Void();
43772 {
43773 if (temp2) delete arg2;
43774 }
43775 return resultobj;
43776 fail:
43777 {
43778 if (temp2) delete arg2;
43779 }
43780 return NULL;
43781 }
43782
43783
43784 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43785 PyObject *resultobj = 0;
43786 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43787 wxString *arg2 = 0 ;
43788 int arg3 ;
43789 PyObject *arg4 = (PyObject *) NULL ;
43790 int result;
43791 void *argp1 = 0 ;
43792 int res1 = 0 ;
43793 bool temp2 = false ;
43794 int val3 ;
43795 int ecode3 = 0 ;
43796 PyObject * obj0 = 0 ;
43797 PyObject * obj1 = 0 ;
43798 PyObject * obj2 = 0 ;
43799 PyObject * obj3 = 0 ;
43800 char * kwnames[] = {
43801 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
43802 };
43803
43804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43806 if (!SWIG_IsOK(res1)) {
43807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43808 }
43809 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43810 {
43811 arg2 = wxString_in_helper(obj1);
43812 if (arg2 == NULL) SWIG_fail;
43813 temp2 = true;
43814 }
43815 ecode3 = SWIG_AsVal_int(obj2, &val3);
43816 if (!SWIG_IsOK(ecode3)) {
43817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
43818 }
43819 arg3 = static_cast< int >(val3);
43820 if (obj3) {
43821 arg4 = obj3;
43822 }
43823 {
43824 PyThreadState* __tstate = wxPyBeginAllowThreads();
43825 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
43826 wxPyEndAllowThreads(__tstate);
43827 if (PyErr_Occurred()) SWIG_fail;
43828 }
43829 resultobj = SWIG_From_int(static_cast< int >(result));
43830 {
43831 if (temp2)
43832 delete arg2;
43833 }
43834 return resultobj;
43835 fail:
43836 {
43837 if (temp2)
43838 delete arg2;
43839 }
43840 return NULL;
43841 }
43842
43843
43844 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43845 PyObject *resultobj = 0;
43846 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43847 void *argp1 = 0 ;
43848 int res1 = 0 ;
43849 PyObject *swig_obj[1] ;
43850
43851 if (!args) SWIG_fail;
43852 swig_obj[0] = args;
43853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43854 if (!SWIG_IsOK(res1)) {
43855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43856 }
43857 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43858 {
43859 PyThreadState* __tstate = wxPyBeginAllowThreads();
43860 (arg1)->Clear();
43861 wxPyEndAllowThreads(__tstate);
43862 if (PyErr_Occurred()) SWIG_fail;
43863 }
43864 resultobj = SWIG_Py_Void();
43865 return resultobj;
43866 fail:
43867 return NULL;
43868 }
43869
43870
43871 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43872 PyObject *resultobj = 0;
43873 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43874 int arg2 ;
43875 void *argp1 = 0 ;
43876 int res1 = 0 ;
43877 int val2 ;
43878 int ecode2 = 0 ;
43879 PyObject * obj0 = 0 ;
43880 PyObject * obj1 = 0 ;
43881 char * kwnames[] = {
43882 (char *) "self",(char *) "n", NULL
43883 };
43884
43885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43887 if (!SWIG_IsOK(res1)) {
43888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43889 }
43890 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43891 ecode2 = SWIG_AsVal_int(obj1, &val2);
43892 if (!SWIG_IsOK(ecode2)) {
43893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
43894 }
43895 arg2 = static_cast< int >(val2);
43896 {
43897 PyThreadState* __tstate = wxPyBeginAllowThreads();
43898 (arg1)->Delete(arg2);
43899 wxPyEndAllowThreads(__tstate);
43900 if (PyErr_Occurred()) SWIG_fail;
43901 }
43902 resultobj = SWIG_Py_Void();
43903 return resultobj;
43904 fail:
43905 return NULL;
43906 }
43907
43908
43909 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43910 PyObject *resultobj = 0;
43911 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43912 int arg2 ;
43913 PyObject *result = 0 ;
43914 void *argp1 = 0 ;
43915 int res1 = 0 ;
43916 int val2 ;
43917 int ecode2 = 0 ;
43918 PyObject * obj0 = 0 ;
43919 PyObject * obj1 = 0 ;
43920 char * kwnames[] = {
43921 (char *) "self",(char *) "n", NULL
43922 };
43923
43924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
43925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43926 if (!SWIG_IsOK(res1)) {
43927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43928 }
43929 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43930 ecode2 = SWIG_AsVal_int(obj1, &val2);
43931 if (!SWIG_IsOK(ecode2)) {
43932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
43933 }
43934 arg2 = static_cast< int >(val2);
43935 {
43936 PyThreadState* __tstate = wxPyBeginAllowThreads();
43937 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
43938 wxPyEndAllowThreads(__tstate);
43939 if (PyErr_Occurred()) SWIG_fail;
43940 }
43941 resultobj = result;
43942 return resultobj;
43943 fail:
43944 return NULL;
43945 }
43946
43947
43948 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43949 PyObject *resultobj = 0;
43950 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43951 int arg2 ;
43952 PyObject *arg3 = (PyObject *) 0 ;
43953 void *argp1 = 0 ;
43954 int res1 = 0 ;
43955 int val2 ;
43956 int ecode2 = 0 ;
43957 PyObject * obj0 = 0 ;
43958 PyObject * obj1 = 0 ;
43959 PyObject * obj2 = 0 ;
43960 char * kwnames[] = {
43961 (char *) "self",(char *) "n",(char *) "clientData", NULL
43962 };
43963
43964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43966 if (!SWIG_IsOK(res1)) {
43967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43968 }
43969 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43970 ecode2 = SWIG_AsVal_int(obj1, &val2);
43971 if (!SWIG_IsOK(ecode2)) {
43972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
43973 }
43974 arg2 = static_cast< int >(val2);
43975 arg3 = obj2;
43976 {
43977 PyThreadState* __tstate = wxPyBeginAllowThreads();
43978 wxItemContainer_SetClientData(arg1,arg2,arg3);
43979 wxPyEndAllowThreads(__tstate);
43980 if (PyErr_Occurred()) SWIG_fail;
43981 }
43982 resultobj = SWIG_Py_Void();
43983 return resultobj;
43984 fail:
43985 return NULL;
43986 }
43987
43988
43989 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43990 PyObject *resultobj = 0;
43991 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43992 int result;
43993 void *argp1 = 0 ;
43994 int res1 = 0 ;
43995 PyObject *swig_obj[1] ;
43996
43997 if (!args) SWIG_fail;
43998 swig_obj[0] = args;
43999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44000 if (!SWIG_IsOK(res1)) {
44001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44002 }
44003 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44004 {
44005 PyThreadState* __tstate = wxPyBeginAllowThreads();
44006 result = (int)((wxItemContainer const *)arg1)->GetCount();
44007 wxPyEndAllowThreads(__tstate);
44008 if (PyErr_Occurred()) SWIG_fail;
44009 }
44010 resultobj = SWIG_From_int(static_cast< int >(result));
44011 return resultobj;
44012 fail:
44013 return NULL;
44014 }
44015
44016
44017 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44018 PyObject *resultobj = 0;
44019 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44020 bool result;
44021 void *argp1 = 0 ;
44022 int res1 = 0 ;
44023 PyObject *swig_obj[1] ;
44024
44025 if (!args) SWIG_fail;
44026 swig_obj[0] = args;
44027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44028 if (!SWIG_IsOK(res1)) {
44029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44030 }
44031 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44032 {
44033 PyThreadState* __tstate = wxPyBeginAllowThreads();
44034 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44035 wxPyEndAllowThreads(__tstate);
44036 if (PyErr_Occurred()) SWIG_fail;
44037 }
44038 {
44039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44040 }
44041 return resultobj;
44042 fail:
44043 return NULL;
44044 }
44045
44046
44047 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44048 PyObject *resultobj = 0;
44049 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44050 int arg2 ;
44051 wxString result;
44052 void *argp1 = 0 ;
44053 int res1 = 0 ;
44054 int val2 ;
44055 int ecode2 = 0 ;
44056 PyObject * obj0 = 0 ;
44057 PyObject * obj1 = 0 ;
44058 char * kwnames[] = {
44059 (char *) "self",(char *) "n", NULL
44060 };
44061
44062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44064 if (!SWIG_IsOK(res1)) {
44065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44066 }
44067 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44068 ecode2 = SWIG_AsVal_int(obj1, &val2);
44069 if (!SWIG_IsOK(ecode2)) {
44070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
44071 }
44072 arg2 = static_cast< int >(val2);
44073 {
44074 PyThreadState* __tstate = wxPyBeginAllowThreads();
44075 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44076 wxPyEndAllowThreads(__tstate);
44077 if (PyErr_Occurred()) SWIG_fail;
44078 }
44079 {
44080 #if wxUSE_UNICODE
44081 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44082 #else
44083 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44084 #endif
44085 }
44086 return resultobj;
44087 fail:
44088 return NULL;
44089 }
44090
44091
44092 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44093 PyObject *resultobj = 0;
44094 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44095 wxArrayString result;
44096 void *argp1 = 0 ;
44097 int res1 = 0 ;
44098 PyObject *swig_obj[1] ;
44099
44100 if (!args) SWIG_fail;
44101 swig_obj[0] = args;
44102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44103 if (!SWIG_IsOK(res1)) {
44104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44105 }
44106 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44107 {
44108 PyThreadState* __tstate = wxPyBeginAllowThreads();
44109 result = ((wxItemContainer const *)arg1)->GetStrings();
44110 wxPyEndAllowThreads(__tstate);
44111 if (PyErr_Occurred()) SWIG_fail;
44112 }
44113 {
44114 resultobj = wxArrayString2PyList_helper(result);
44115 }
44116 return resultobj;
44117 fail:
44118 return NULL;
44119 }
44120
44121
44122 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44123 PyObject *resultobj = 0;
44124 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44125 int arg2 ;
44126 wxString *arg3 = 0 ;
44127 void *argp1 = 0 ;
44128 int res1 = 0 ;
44129 int val2 ;
44130 int ecode2 = 0 ;
44131 bool temp3 = false ;
44132 PyObject * obj0 = 0 ;
44133 PyObject * obj1 = 0 ;
44134 PyObject * obj2 = 0 ;
44135 char * kwnames[] = {
44136 (char *) "self",(char *) "n",(char *) "s", NULL
44137 };
44138
44139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44141 if (!SWIG_IsOK(res1)) {
44142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44143 }
44144 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44145 ecode2 = SWIG_AsVal_int(obj1, &val2);
44146 if (!SWIG_IsOK(ecode2)) {
44147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
44148 }
44149 arg2 = static_cast< int >(val2);
44150 {
44151 arg3 = wxString_in_helper(obj2);
44152 if (arg3 == NULL) SWIG_fail;
44153 temp3 = true;
44154 }
44155 {
44156 PyThreadState* __tstate = wxPyBeginAllowThreads();
44157 (arg1)->SetString(arg2,(wxString const &)*arg3);
44158 wxPyEndAllowThreads(__tstate);
44159 if (PyErr_Occurred()) SWIG_fail;
44160 }
44161 resultobj = SWIG_Py_Void();
44162 {
44163 if (temp3)
44164 delete arg3;
44165 }
44166 return resultobj;
44167 fail:
44168 {
44169 if (temp3)
44170 delete arg3;
44171 }
44172 return NULL;
44173 }
44174
44175
44176 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44177 PyObject *resultobj = 0;
44178 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44179 wxString *arg2 = 0 ;
44180 int result;
44181 void *argp1 = 0 ;
44182 int res1 = 0 ;
44183 bool temp2 = false ;
44184 PyObject * obj0 = 0 ;
44185 PyObject * obj1 = 0 ;
44186 char * kwnames[] = {
44187 (char *) "self",(char *) "s", NULL
44188 };
44189
44190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44192 if (!SWIG_IsOK(res1)) {
44193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44194 }
44195 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44196 {
44197 arg2 = wxString_in_helper(obj1);
44198 if (arg2 == NULL) SWIG_fail;
44199 temp2 = true;
44200 }
44201 {
44202 PyThreadState* __tstate = wxPyBeginAllowThreads();
44203 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44204 wxPyEndAllowThreads(__tstate);
44205 if (PyErr_Occurred()) SWIG_fail;
44206 }
44207 resultobj = SWIG_From_int(static_cast< int >(result));
44208 {
44209 if (temp2)
44210 delete arg2;
44211 }
44212 return resultobj;
44213 fail:
44214 {
44215 if (temp2)
44216 delete arg2;
44217 }
44218 return NULL;
44219 }
44220
44221
44222 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44223 PyObject *resultobj = 0;
44224 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44225 int arg2 ;
44226 void *argp1 = 0 ;
44227 int res1 = 0 ;
44228 int val2 ;
44229 int ecode2 = 0 ;
44230 PyObject * obj0 = 0 ;
44231 PyObject * obj1 = 0 ;
44232 char * kwnames[] = {
44233 (char *) "self",(char *) "n", NULL
44234 };
44235
44236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44238 if (!SWIG_IsOK(res1)) {
44239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44240 }
44241 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44242 ecode2 = SWIG_AsVal_int(obj1, &val2);
44243 if (!SWIG_IsOK(ecode2)) {
44244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44245 }
44246 arg2 = static_cast< int >(val2);
44247 {
44248 PyThreadState* __tstate = wxPyBeginAllowThreads();
44249 (arg1)->SetSelection(arg2);
44250 wxPyEndAllowThreads(__tstate);
44251 if (PyErr_Occurred()) SWIG_fail;
44252 }
44253 resultobj = SWIG_Py_Void();
44254 return resultobj;
44255 fail:
44256 return NULL;
44257 }
44258
44259
44260 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44261 PyObject *resultobj = 0;
44262 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44263 int result;
44264 void *argp1 = 0 ;
44265 int res1 = 0 ;
44266 PyObject *swig_obj[1] ;
44267
44268 if (!args) SWIG_fail;
44269 swig_obj[0] = args;
44270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44271 if (!SWIG_IsOK(res1)) {
44272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44273 }
44274 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44275 {
44276 PyThreadState* __tstate = wxPyBeginAllowThreads();
44277 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44278 wxPyEndAllowThreads(__tstate);
44279 if (PyErr_Occurred()) SWIG_fail;
44280 }
44281 resultobj = SWIG_From_int(static_cast< int >(result));
44282 return resultobj;
44283 fail:
44284 return NULL;
44285 }
44286
44287
44288 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44289 PyObject *resultobj = 0;
44290 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44291 wxString *arg2 = 0 ;
44292 bool result;
44293 void *argp1 = 0 ;
44294 int res1 = 0 ;
44295 bool temp2 = false ;
44296 PyObject * obj0 = 0 ;
44297 PyObject * obj1 = 0 ;
44298 char * kwnames[] = {
44299 (char *) "self",(char *) "s", NULL
44300 };
44301
44302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) 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_SetStringSelection" "', 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 {
44314 PyThreadState* __tstate = wxPyBeginAllowThreads();
44315 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44316 wxPyEndAllowThreads(__tstate);
44317 if (PyErr_Occurred()) SWIG_fail;
44318 }
44319 {
44320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44321 }
44322 {
44323 if (temp2)
44324 delete arg2;
44325 }
44326 return resultobj;
44327 fail:
44328 {
44329 if (temp2)
44330 delete arg2;
44331 }
44332 return NULL;
44333 }
44334
44335
44336 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44337 PyObject *resultobj = 0;
44338 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44339 wxString result;
44340 void *argp1 = 0 ;
44341 int res1 = 0 ;
44342 PyObject *swig_obj[1] ;
44343
44344 if (!args) SWIG_fail;
44345 swig_obj[0] = args;
44346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44347 if (!SWIG_IsOK(res1)) {
44348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44349 }
44350 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44351 {
44352 PyThreadState* __tstate = wxPyBeginAllowThreads();
44353 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44354 wxPyEndAllowThreads(__tstate);
44355 if (PyErr_Occurred()) SWIG_fail;
44356 }
44357 {
44358 #if wxUSE_UNICODE
44359 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44360 #else
44361 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44362 #endif
44363 }
44364 return resultobj;
44365 fail:
44366 return NULL;
44367 }
44368
44369
44370 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44371 PyObject *resultobj = 0;
44372 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44373 int arg2 ;
44374 void *argp1 = 0 ;
44375 int res1 = 0 ;
44376 int val2 ;
44377 int ecode2 = 0 ;
44378 PyObject * obj0 = 0 ;
44379 PyObject * obj1 = 0 ;
44380 char * kwnames[] = {
44381 (char *) "self",(char *) "n", NULL
44382 };
44383
44384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44386 if (!SWIG_IsOK(res1)) {
44387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44388 }
44389 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44390 ecode2 = SWIG_AsVal_int(obj1, &val2);
44391 if (!SWIG_IsOK(ecode2)) {
44392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44393 }
44394 arg2 = static_cast< int >(val2);
44395 {
44396 PyThreadState* __tstate = wxPyBeginAllowThreads();
44397 (arg1)->Select(arg2);
44398 wxPyEndAllowThreads(__tstate);
44399 if (PyErr_Occurred()) SWIG_fail;
44400 }
44401 resultobj = SWIG_Py_Void();
44402 return resultobj;
44403 fail:
44404 return NULL;
44405 }
44406
44407
44408 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44409 PyObject *obj;
44410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44411 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44412 return SWIG_Py_Void();
44413 }
44414
44415 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44416 PyObject *obj;
44417 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44418 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44419 return SWIG_Py_Void();
44420 }
44421
44422 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44423 PyObject *resultobj = 0;
44424 wxSizerItem *result = 0 ;
44425
44426 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44427 {
44428 PyThreadState* __tstate = wxPyBeginAllowThreads();
44429 result = (wxSizerItem *)new wxSizerItem();
44430 wxPyEndAllowThreads(__tstate);
44431 if (PyErr_Occurred()) SWIG_fail;
44432 }
44433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44434 return resultobj;
44435 fail:
44436 return NULL;
44437 }
44438
44439
44440 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44441 PyObject *resultobj = 0;
44442 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44443 void *argp1 = 0 ;
44444 int res1 = 0 ;
44445 PyObject *swig_obj[1] ;
44446
44447 if (!args) SWIG_fail;
44448 swig_obj[0] = args;
44449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44450 if (!SWIG_IsOK(res1)) {
44451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44452 }
44453 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44454 {
44455 PyThreadState* __tstate = wxPyBeginAllowThreads();
44456 delete arg1;
44457
44458 wxPyEndAllowThreads(__tstate);
44459 if (PyErr_Occurred()) SWIG_fail;
44460 }
44461 resultobj = SWIG_Py_Void();
44462 return resultobj;
44463 fail:
44464 return NULL;
44465 }
44466
44467
44468 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44469 PyObject *resultobj = 0;
44470 wxWindow *arg1 = (wxWindow *) 0 ;
44471 int arg2 ;
44472 int arg3 ;
44473 int arg4 ;
44474 PyObject *arg5 = (PyObject *) NULL ;
44475 wxSizerItem *result = 0 ;
44476 void *argp1 = 0 ;
44477 int res1 = 0 ;
44478 int val2 ;
44479 int ecode2 = 0 ;
44480 int val3 ;
44481 int ecode3 = 0 ;
44482 int val4 ;
44483 int ecode4 = 0 ;
44484 PyObject * obj0 = 0 ;
44485 PyObject * obj1 = 0 ;
44486 PyObject * obj2 = 0 ;
44487 PyObject * obj3 = 0 ;
44488 PyObject * obj4 = 0 ;
44489 char * kwnames[] = {
44490 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44491 };
44492
44493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44495 if (!SWIG_IsOK(res1)) {
44496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44497 }
44498 arg1 = reinterpret_cast< wxWindow * >(argp1);
44499 ecode2 = SWIG_AsVal_int(obj1, &val2);
44500 if (!SWIG_IsOK(ecode2)) {
44501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44502 }
44503 arg2 = static_cast< int >(val2);
44504 ecode3 = SWIG_AsVal_int(obj2, &val3);
44505 if (!SWIG_IsOK(ecode3)) {
44506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44507 }
44508 arg3 = static_cast< int >(val3);
44509 ecode4 = SWIG_AsVal_int(obj3, &val4);
44510 if (!SWIG_IsOK(ecode4)) {
44511 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44512 }
44513 arg4 = static_cast< int >(val4);
44514 if (obj4) {
44515 arg5 = obj4;
44516 }
44517 {
44518 PyThreadState* __tstate = wxPyBeginAllowThreads();
44519 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44520 wxPyEndAllowThreads(__tstate);
44521 if (PyErr_Occurred()) SWIG_fail;
44522 }
44523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44524 return resultobj;
44525 fail:
44526 return NULL;
44527 }
44528
44529
44530 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44531 PyObject *resultobj = 0;
44532 int arg1 ;
44533 int arg2 ;
44534 int arg3 ;
44535 int arg4 ;
44536 int arg5 ;
44537 PyObject *arg6 = (PyObject *) NULL ;
44538 wxSizerItem *result = 0 ;
44539 int val1 ;
44540 int ecode1 = 0 ;
44541 int val2 ;
44542 int ecode2 = 0 ;
44543 int val3 ;
44544 int ecode3 = 0 ;
44545 int val4 ;
44546 int ecode4 = 0 ;
44547 int val5 ;
44548 int ecode5 = 0 ;
44549 PyObject * obj0 = 0 ;
44550 PyObject * obj1 = 0 ;
44551 PyObject * obj2 = 0 ;
44552 PyObject * obj3 = 0 ;
44553 PyObject * obj4 = 0 ;
44554 PyObject * obj5 = 0 ;
44555 char * kwnames[] = {
44556 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44557 };
44558
44559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44560 ecode1 = SWIG_AsVal_int(obj0, &val1);
44561 if (!SWIG_IsOK(ecode1)) {
44562 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44563 }
44564 arg1 = static_cast< int >(val1);
44565 ecode2 = SWIG_AsVal_int(obj1, &val2);
44566 if (!SWIG_IsOK(ecode2)) {
44567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44568 }
44569 arg2 = static_cast< int >(val2);
44570 ecode3 = SWIG_AsVal_int(obj2, &val3);
44571 if (!SWIG_IsOK(ecode3)) {
44572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44573 }
44574 arg3 = static_cast< int >(val3);
44575 ecode4 = SWIG_AsVal_int(obj3, &val4);
44576 if (!SWIG_IsOK(ecode4)) {
44577 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44578 }
44579 arg4 = static_cast< int >(val4);
44580 ecode5 = SWIG_AsVal_int(obj4, &val5);
44581 if (!SWIG_IsOK(ecode5)) {
44582 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44583 }
44584 arg5 = static_cast< int >(val5);
44585 if (obj5) {
44586 arg6 = obj5;
44587 }
44588 {
44589 PyThreadState* __tstate = wxPyBeginAllowThreads();
44590 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44591 wxPyEndAllowThreads(__tstate);
44592 if (PyErr_Occurred()) SWIG_fail;
44593 }
44594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44595 return resultobj;
44596 fail:
44597 return NULL;
44598 }
44599
44600
44601 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44602 PyObject *resultobj = 0;
44603 wxSizer *arg1 = (wxSizer *) 0 ;
44604 int arg2 ;
44605 int arg3 ;
44606 int arg4 ;
44607 PyObject *arg5 = (PyObject *) NULL ;
44608 wxSizerItem *result = 0 ;
44609 int res1 = 0 ;
44610 int val2 ;
44611 int ecode2 = 0 ;
44612 int val3 ;
44613 int ecode3 = 0 ;
44614 int val4 ;
44615 int ecode4 = 0 ;
44616 PyObject * obj0 = 0 ;
44617 PyObject * obj1 = 0 ;
44618 PyObject * obj2 = 0 ;
44619 PyObject * obj3 = 0 ;
44620 PyObject * obj4 = 0 ;
44621 char * kwnames[] = {
44622 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44623 };
44624
44625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44626 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44627 if (!SWIG_IsOK(res1)) {
44628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44629 }
44630 ecode2 = SWIG_AsVal_int(obj1, &val2);
44631 if (!SWIG_IsOK(ecode2)) {
44632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44633 }
44634 arg2 = static_cast< int >(val2);
44635 ecode3 = SWIG_AsVal_int(obj2, &val3);
44636 if (!SWIG_IsOK(ecode3)) {
44637 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44638 }
44639 arg3 = static_cast< int >(val3);
44640 ecode4 = SWIG_AsVal_int(obj3, &val4);
44641 if (!SWIG_IsOK(ecode4)) {
44642 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44643 }
44644 arg4 = static_cast< int >(val4);
44645 if (obj4) {
44646 arg5 = obj4;
44647 }
44648 {
44649 PyThreadState* __tstate = wxPyBeginAllowThreads();
44650 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44651 wxPyEndAllowThreads(__tstate);
44652 if (PyErr_Occurred()) SWIG_fail;
44653 }
44654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44655 return resultobj;
44656 fail:
44657 return NULL;
44658 }
44659
44660
44661 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44662 PyObject *resultobj = 0;
44663 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44664 void *argp1 = 0 ;
44665 int res1 = 0 ;
44666 PyObject *swig_obj[1] ;
44667
44668 if (!args) SWIG_fail;
44669 swig_obj[0] = args;
44670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44671 if (!SWIG_IsOK(res1)) {
44672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44673 }
44674 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44675 {
44676 PyThreadState* __tstate = wxPyBeginAllowThreads();
44677 (arg1)->DeleteWindows();
44678 wxPyEndAllowThreads(__tstate);
44679 if (PyErr_Occurred()) SWIG_fail;
44680 }
44681 resultobj = SWIG_Py_Void();
44682 return resultobj;
44683 fail:
44684 return NULL;
44685 }
44686
44687
44688 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44689 PyObject *resultobj = 0;
44690 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44691 void *argp1 = 0 ;
44692 int res1 = 0 ;
44693 PyObject *swig_obj[1] ;
44694
44695 if (!args) SWIG_fail;
44696 swig_obj[0] = args;
44697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44698 if (!SWIG_IsOK(res1)) {
44699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44700 }
44701 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44702 {
44703 PyThreadState* __tstate = wxPyBeginAllowThreads();
44704 (arg1)->DetachSizer();
44705 wxPyEndAllowThreads(__tstate);
44706 if (PyErr_Occurred()) SWIG_fail;
44707 }
44708 resultobj = SWIG_Py_Void();
44709 return resultobj;
44710 fail:
44711 return NULL;
44712 }
44713
44714
44715 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44716 PyObject *resultobj = 0;
44717 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44718 wxSize result;
44719 void *argp1 = 0 ;
44720 int res1 = 0 ;
44721 PyObject *swig_obj[1] ;
44722
44723 if (!args) SWIG_fail;
44724 swig_obj[0] = args;
44725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44726 if (!SWIG_IsOK(res1)) {
44727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44728 }
44729 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44730 {
44731 PyThreadState* __tstate = wxPyBeginAllowThreads();
44732 result = (arg1)->GetSize();
44733 wxPyEndAllowThreads(__tstate);
44734 if (PyErr_Occurred()) SWIG_fail;
44735 }
44736 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44737 return resultobj;
44738 fail:
44739 return NULL;
44740 }
44741
44742
44743 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44744 PyObject *resultobj = 0;
44745 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44746 wxSize result;
44747 void *argp1 = 0 ;
44748 int res1 = 0 ;
44749 PyObject *swig_obj[1] ;
44750
44751 if (!args) SWIG_fail;
44752 swig_obj[0] = args;
44753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44754 if (!SWIG_IsOK(res1)) {
44755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44756 }
44757 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44758 {
44759 PyThreadState* __tstate = wxPyBeginAllowThreads();
44760 result = (arg1)->CalcMin();
44761 wxPyEndAllowThreads(__tstate);
44762 if (PyErr_Occurred()) SWIG_fail;
44763 }
44764 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44765 return resultobj;
44766 fail:
44767 return NULL;
44768 }
44769
44770
44771 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44772 PyObject *resultobj = 0;
44773 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44774 wxPoint *arg2 = 0 ;
44775 wxSize *arg3 = 0 ;
44776 void *argp1 = 0 ;
44777 int res1 = 0 ;
44778 wxPoint temp2 ;
44779 wxSize temp3 ;
44780 PyObject * obj0 = 0 ;
44781 PyObject * obj1 = 0 ;
44782 PyObject * obj2 = 0 ;
44783 char * kwnames[] = {
44784 (char *) "self",(char *) "pos",(char *) "size", NULL
44785 };
44786
44787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44789 if (!SWIG_IsOK(res1)) {
44790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44791 }
44792 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44793 {
44794 arg2 = &temp2;
44795 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44796 }
44797 {
44798 arg3 = &temp3;
44799 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
44800 }
44801 {
44802 PyThreadState* __tstate = wxPyBeginAllowThreads();
44803 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
44804 wxPyEndAllowThreads(__tstate);
44805 if (PyErr_Occurred()) SWIG_fail;
44806 }
44807 resultobj = SWIG_Py_Void();
44808 return resultobj;
44809 fail:
44810 return NULL;
44811 }
44812
44813
44814 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44815 PyObject *resultobj = 0;
44816 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44817 wxSize result;
44818 void *argp1 = 0 ;
44819 int res1 = 0 ;
44820 PyObject *swig_obj[1] ;
44821
44822 if (!args) SWIG_fail;
44823 swig_obj[0] = args;
44824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44825 if (!SWIG_IsOK(res1)) {
44826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44827 }
44828 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44829 {
44830 PyThreadState* __tstate = wxPyBeginAllowThreads();
44831 result = (arg1)->GetMinSize();
44832 wxPyEndAllowThreads(__tstate);
44833 if (PyErr_Occurred()) SWIG_fail;
44834 }
44835 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44836 return resultobj;
44837 fail:
44838 return NULL;
44839 }
44840
44841
44842 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44843 PyObject *resultobj = 0;
44844 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44845 wxSize result;
44846 void *argp1 = 0 ;
44847 int res1 = 0 ;
44848 PyObject *swig_obj[1] ;
44849
44850 if (!args) SWIG_fail;
44851 swig_obj[0] = args;
44852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44853 if (!SWIG_IsOK(res1)) {
44854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
44855 }
44856 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44857 {
44858 PyThreadState* __tstate = wxPyBeginAllowThreads();
44859 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
44860 wxPyEndAllowThreads(__tstate);
44861 if (PyErr_Occurred()) SWIG_fail;
44862 }
44863 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44864 return resultobj;
44865 fail:
44866 return NULL;
44867 }
44868
44869
44870 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44871 PyObject *resultobj = 0;
44872 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44873 int arg2 ;
44874 int arg3 ;
44875 void *argp1 = 0 ;
44876 int res1 = 0 ;
44877 int val2 ;
44878 int ecode2 = 0 ;
44879 int val3 ;
44880 int ecode3 = 0 ;
44881 PyObject * obj0 = 0 ;
44882 PyObject * obj1 = 0 ;
44883 PyObject * obj2 = 0 ;
44884 char * kwnames[] = {
44885 (char *) "self",(char *) "x",(char *) "y", NULL
44886 };
44887
44888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44890 if (!SWIG_IsOK(res1)) {
44891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44892 }
44893 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44894 ecode2 = SWIG_AsVal_int(obj1, &val2);
44895 if (!SWIG_IsOK(ecode2)) {
44896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
44897 }
44898 arg2 = static_cast< int >(val2);
44899 ecode3 = SWIG_AsVal_int(obj2, &val3);
44900 if (!SWIG_IsOK(ecode3)) {
44901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
44902 }
44903 arg3 = static_cast< int >(val3);
44904 {
44905 PyThreadState* __tstate = wxPyBeginAllowThreads();
44906 (arg1)->SetInitSize(arg2,arg3);
44907 wxPyEndAllowThreads(__tstate);
44908 if (PyErr_Occurred()) SWIG_fail;
44909 }
44910 resultobj = SWIG_Py_Void();
44911 return resultobj;
44912 fail:
44913 return NULL;
44914 }
44915
44916
44917 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44918 PyObject *resultobj = 0;
44919 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44920 int arg2 ;
44921 int arg3 ;
44922 void *argp1 = 0 ;
44923 int res1 = 0 ;
44924 int val2 ;
44925 int ecode2 = 0 ;
44926 int val3 ;
44927 int ecode3 = 0 ;
44928 PyObject * obj0 = 0 ;
44929 PyObject * obj1 = 0 ;
44930 PyObject * obj2 = 0 ;
44931 char * kwnames[] = {
44932 (char *) "self",(char *) "width",(char *) "height", NULL
44933 };
44934
44935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44937 if (!SWIG_IsOK(res1)) {
44938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44939 }
44940 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44941 ecode2 = SWIG_AsVal_int(obj1, &val2);
44942 if (!SWIG_IsOK(ecode2)) {
44943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
44944 }
44945 arg2 = static_cast< int >(val2);
44946 ecode3 = SWIG_AsVal_int(obj2, &val3);
44947 if (!SWIG_IsOK(ecode3)) {
44948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
44949 }
44950 arg3 = static_cast< int >(val3);
44951 {
44952 PyThreadState* __tstate = wxPyBeginAllowThreads();
44953 (arg1)->SetRatio(arg2,arg3);
44954 wxPyEndAllowThreads(__tstate);
44955 if (PyErr_Occurred()) SWIG_fail;
44956 }
44957 resultobj = SWIG_Py_Void();
44958 return resultobj;
44959 fail:
44960 return NULL;
44961 }
44962
44963
44964 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44965 PyObject *resultobj = 0;
44966 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44967 wxSize *arg2 = 0 ;
44968 void *argp1 = 0 ;
44969 int res1 = 0 ;
44970 wxSize temp2 ;
44971 PyObject * obj0 = 0 ;
44972 PyObject * obj1 = 0 ;
44973 char * kwnames[] = {
44974 (char *) "self",(char *) "size", NULL
44975 };
44976
44977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
44978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44979 if (!SWIG_IsOK(res1)) {
44980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44981 }
44982 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44983 {
44984 arg2 = &temp2;
44985 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
44986 }
44987 {
44988 PyThreadState* __tstate = wxPyBeginAllowThreads();
44989 (arg1)->SetRatio((wxSize const &)*arg2);
44990 wxPyEndAllowThreads(__tstate);
44991 if (PyErr_Occurred()) SWIG_fail;
44992 }
44993 resultobj = SWIG_Py_Void();
44994 return resultobj;
44995 fail:
44996 return NULL;
44997 }
44998
44999
45000 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45001 PyObject *resultobj = 0;
45002 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45003 float arg2 ;
45004 void *argp1 = 0 ;
45005 int res1 = 0 ;
45006 float val2 ;
45007 int ecode2 = 0 ;
45008 PyObject * obj0 = 0 ;
45009 PyObject * obj1 = 0 ;
45010 char * kwnames[] = {
45011 (char *) "self",(char *) "ratio", NULL
45012 };
45013
45014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45016 if (!SWIG_IsOK(res1)) {
45017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45018 }
45019 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45020 ecode2 = SWIG_AsVal_float(obj1, &val2);
45021 if (!SWIG_IsOK(ecode2)) {
45022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45023 }
45024 arg2 = static_cast< float >(val2);
45025 {
45026 PyThreadState* __tstate = wxPyBeginAllowThreads();
45027 (arg1)->SetRatio(arg2);
45028 wxPyEndAllowThreads(__tstate);
45029 if (PyErr_Occurred()) SWIG_fail;
45030 }
45031 resultobj = SWIG_Py_Void();
45032 return resultobj;
45033 fail:
45034 return NULL;
45035 }
45036
45037
45038 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45039 PyObject *resultobj = 0;
45040 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45041 float result;
45042 void *argp1 = 0 ;
45043 int res1 = 0 ;
45044 PyObject *swig_obj[1] ;
45045
45046 if (!args) SWIG_fail;
45047 swig_obj[0] = args;
45048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45049 if (!SWIG_IsOK(res1)) {
45050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45051 }
45052 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45053 {
45054 PyThreadState* __tstate = wxPyBeginAllowThreads();
45055 result = (float)(arg1)->GetRatio();
45056 wxPyEndAllowThreads(__tstate);
45057 if (PyErr_Occurred()) SWIG_fail;
45058 }
45059 resultobj = SWIG_From_float(static_cast< float >(result));
45060 return resultobj;
45061 fail:
45062 return NULL;
45063 }
45064
45065
45066 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45067 PyObject *resultobj = 0;
45068 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45069 wxRect result;
45070 void *argp1 = 0 ;
45071 int res1 = 0 ;
45072 PyObject *swig_obj[1] ;
45073
45074 if (!args) SWIG_fail;
45075 swig_obj[0] = args;
45076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45077 if (!SWIG_IsOK(res1)) {
45078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45079 }
45080 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45081 {
45082 PyThreadState* __tstate = wxPyBeginAllowThreads();
45083 result = (arg1)->GetRect();
45084 wxPyEndAllowThreads(__tstate);
45085 if (PyErr_Occurred()) SWIG_fail;
45086 }
45087 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45088 return resultobj;
45089 fail:
45090 return NULL;
45091 }
45092
45093
45094 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45095 PyObject *resultobj = 0;
45096 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45097 bool result;
45098 void *argp1 = 0 ;
45099 int res1 = 0 ;
45100 PyObject *swig_obj[1] ;
45101
45102 if (!args) SWIG_fail;
45103 swig_obj[0] = args;
45104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45105 if (!SWIG_IsOK(res1)) {
45106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45107 }
45108 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45109 {
45110 PyThreadState* __tstate = wxPyBeginAllowThreads();
45111 result = (bool)(arg1)->IsWindow();
45112 wxPyEndAllowThreads(__tstate);
45113 if (PyErr_Occurred()) SWIG_fail;
45114 }
45115 {
45116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45117 }
45118 return resultobj;
45119 fail:
45120 return NULL;
45121 }
45122
45123
45124 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45125 PyObject *resultobj = 0;
45126 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45127 bool result;
45128 void *argp1 = 0 ;
45129 int res1 = 0 ;
45130 PyObject *swig_obj[1] ;
45131
45132 if (!args) SWIG_fail;
45133 swig_obj[0] = args;
45134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45135 if (!SWIG_IsOK(res1)) {
45136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45137 }
45138 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45139 {
45140 PyThreadState* __tstate = wxPyBeginAllowThreads();
45141 result = (bool)(arg1)->IsSizer();
45142 wxPyEndAllowThreads(__tstate);
45143 if (PyErr_Occurred()) SWIG_fail;
45144 }
45145 {
45146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45147 }
45148 return resultobj;
45149 fail:
45150 return NULL;
45151 }
45152
45153
45154 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45155 PyObject *resultobj = 0;
45156 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45157 bool result;
45158 void *argp1 = 0 ;
45159 int res1 = 0 ;
45160 PyObject *swig_obj[1] ;
45161
45162 if (!args) SWIG_fail;
45163 swig_obj[0] = args;
45164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45165 if (!SWIG_IsOK(res1)) {
45166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45167 }
45168 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45169 {
45170 PyThreadState* __tstate = wxPyBeginAllowThreads();
45171 result = (bool)(arg1)->IsSpacer();
45172 wxPyEndAllowThreads(__tstate);
45173 if (PyErr_Occurred()) SWIG_fail;
45174 }
45175 {
45176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45177 }
45178 return resultobj;
45179 fail:
45180 return NULL;
45181 }
45182
45183
45184 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45185 PyObject *resultobj = 0;
45186 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45187 int arg2 ;
45188 void *argp1 = 0 ;
45189 int res1 = 0 ;
45190 int val2 ;
45191 int ecode2 = 0 ;
45192 PyObject * obj0 = 0 ;
45193 PyObject * obj1 = 0 ;
45194 char * kwnames[] = {
45195 (char *) "self",(char *) "proportion", NULL
45196 };
45197
45198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45200 if (!SWIG_IsOK(res1)) {
45201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45202 }
45203 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45204 ecode2 = SWIG_AsVal_int(obj1, &val2);
45205 if (!SWIG_IsOK(ecode2)) {
45206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45207 }
45208 arg2 = static_cast< int >(val2);
45209 {
45210 PyThreadState* __tstate = wxPyBeginAllowThreads();
45211 (arg1)->SetProportion(arg2);
45212 wxPyEndAllowThreads(__tstate);
45213 if (PyErr_Occurred()) SWIG_fail;
45214 }
45215 resultobj = SWIG_Py_Void();
45216 return resultobj;
45217 fail:
45218 return NULL;
45219 }
45220
45221
45222 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45223 PyObject *resultobj = 0;
45224 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45225 int result;
45226 void *argp1 = 0 ;
45227 int res1 = 0 ;
45228 PyObject *swig_obj[1] ;
45229
45230 if (!args) SWIG_fail;
45231 swig_obj[0] = args;
45232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45233 if (!SWIG_IsOK(res1)) {
45234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45235 }
45236 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45237 {
45238 PyThreadState* __tstate = wxPyBeginAllowThreads();
45239 result = (int)(arg1)->GetProportion();
45240 wxPyEndAllowThreads(__tstate);
45241 if (PyErr_Occurred()) SWIG_fail;
45242 }
45243 resultobj = SWIG_From_int(static_cast< int >(result));
45244 return resultobj;
45245 fail:
45246 return NULL;
45247 }
45248
45249
45250 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45251 PyObject *resultobj = 0;
45252 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45253 int arg2 ;
45254 void *argp1 = 0 ;
45255 int res1 = 0 ;
45256 int val2 ;
45257 int ecode2 = 0 ;
45258 PyObject * obj0 = 0 ;
45259 PyObject * obj1 = 0 ;
45260 char * kwnames[] = {
45261 (char *) "self",(char *) "flag", NULL
45262 };
45263
45264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45266 if (!SWIG_IsOK(res1)) {
45267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45268 }
45269 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45270 ecode2 = SWIG_AsVal_int(obj1, &val2);
45271 if (!SWIG_IsOK(ecode2)) {
45272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45273 }
45274 arg2 = static_cast< int >(val2);
45275 {
45276 PyThreadState* __tstate = wxPyBeginAllowThreads();
45277 (arg1)->SetFlag(arg2);
45278 wxPyEndAllowThreads(__tstate);
45279 if (PyErr_Occurred()) SWIG_fail;
45280 }
45281 resultobj = SWIG_Py_Void();
45282 return resultobj;
45283 fail:
45284 return NULL;
45285 }
45286
45287
45288 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45289 PyObject *resultobj = 0;
45290 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45291 int result;
45292 void *argp1 = 0 ;
45293 int res1 = 0 ;
45294 PyObject *swig_obj[1] ;
45295
45296 if (!args) SWIG_fail;
45297 swig_obj[0] = args;
45298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45299 if (!SWIG_IsOK(res1)) {
45300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45301 }
45302 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45303 {
45304 PyThreadState* __tstate = wxPyBeginAllowThreads();
45305 result = (int)(arg1)->GetFlag();
45306 wxPyEndAllowThreads(__tstate);
45307 if (PyErr_Occurred()) SWIG_fail;
45308 }
45309 resultobj = SWIG_From_int(static_cast< int >(result));
45310 return resultobj;
45311 fail:
45312 return NULL;
45313 }
45314
45315
45316 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45317 PyObject *resultobj = 0;
45318 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45319 int arg2 ;
45320 void *argp1 = 0 ;
45321 int res1 = 0 ;
45322 int val2 ;
45323 int ecode2 = 0 ;
45324 PyObject * obj0 = 0 ;
45325 PyObject * obj1 = 0 ;
45326 char * kwnames[] = {
45327 (char *) "self",(char *) "border", NULL
45328 };
45329
45330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45332 if (!SWIG_IsOK(res1)) {
45333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45334 }
45335 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45336 ecode2 = SWIG_AsVal_int(obj1, &val2);
45337 if (!SWIG_IsOK(ecode2)) {
45338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45339 }
45340 arg2 = static_cast< int >(val2);
45341 {
45342 PyThreadState* __tstate = wxPyBeginAllowThreads();
45343 (arg1)->SetBorder(arg2);
45344 wxPyEndAllowThreads(__tstate);
45345 if (PyErr_Occurred()) SWIG_fail;
45346 }
45347 resultobj = SWIG_Py_Void();
45348 return resultobj;
45349 fail:
45350 return NULL;
45351 }
45352
45353
45354 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45355 PyObject *resultobj = 0;
45356 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45357 int result;
45358 void *argp1 = 0 ;
45359 int res1 = 0 ;
45360 PyObject *swig_obj[1] ;
45361
45362 if (!args) SWIG_fail;
45363 swig_obj[0] = args;
45364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45365 if (!SWIG_IsOK(res1)) {
45366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45367 }
45368 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45369 {
45370 PyThreadState* __tstate = wxPyBeginAllowThreads();
45371 result = (int)(arg1)->GetBorder();
45372 wxPyEndAllowThreads(__tstate);
45373 if (PyErr_Occurred()) SWIG_fail;
45374 }
45375 resultobj = SWIG_From_int(static_cast< int >(result));
45376 return resultobj;
45377 fail:
45378 return NULL;
45379 }
45380
45381
45382 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45383 PyObject *resultobj = 0;
45384 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45385 wxWindow *result = 0 ;
45386 void *argp1 = 0 ;
45387 int res1 = 0 ;
45388 PyObject *swig_obj[1] ;
45389
45390 if (!args) SWIG_fail;
45391 swig_obj[0] = args;
45392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45393 if (!SWIG_IsOK(res1)) {
45394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45395 }
45396 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45397 {
45398 PyThreadState* __tstate = wxPyBeginAllowThreads();
45399 result = (wxWindow *)(arg1)->GetWindow();
45400 wxPyEndAllowThreads(__tstate);
45401 if (PyErr_Occurred()) SWIG_fail;
45402 }
45403 {
45404 resultobj = wxPyMake_wxObject(result, 0);
45405 }
45406 return resultobj;
45407 fail:
45408 return NULL;
45409 }
45410
45411
45412 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45413 PyObject *resultobj = 0;
45414 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45415 wxWindow *arg2 = (wxWindow *) 0 ;
45416 void *argp1 = 0 ;
45417 int res1 = 0 ;
45418 void *argp2 = 0 ;
45419 int res2 = 0 ;
45420 PyObject * obj0 = 0 ;
45421 PyObject * obj1 = 0 ;
45422 char * kwnames[] = {
45423 (char *) "self",(char *) "window", NULL
45424 };
45425
45426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45428 if (!SWIG_IsOK(res1)) {
45429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45430 }
45431 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45432 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45433 if (!SWIG_IsOK(res2)) {
45434 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45435 }
45436 arg2 = reinterpret_cast< wxWindow * >(argp2);
45437 {
45438 PyThreadState* __tstate = wxPyBeginAllowThreads();
45439 (arg1)->SetWindow(arg2);
45440 wxPyEndAllowThreads(__tstate);
45441 if (PyErr_Occurred()) SWIG_fail;
45442 }
45443 resultobj = SWIG_Py_Void();
45444 return resultobj;
45445 fail:
45446 return NULL;
45447 }
45448
45449
45450 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45451 PyObject *resultobj = 0;
45452 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45453 wxSizer *result = 0 ;
45454 void *argp1 = 0 ;
45455 int res1 = 0 ;
45456 PyObject *swig_obj[1] ;
45457
45458 if (!args) SWIG_fail;
45459 swig_obj[0] = args;
45460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45461 if (!SWIG_IsOK(res1)) {
45462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45463 }
45464 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45465 {
45466 PyThreadState* __tstate = wxPyBeginAllowThreads();
45467 result = (wxSizer *)(arg1)->GetSizer();
45468 wxPyEndAllowThreads(__tstate);
45469 if (PyErr_Occurred()) SWIG_fail;
45470 }
45471 {
45472 resultobj = wxPyMake_wxObject(result, (bool)0);
45473 }
45474 return resultobj;
45475 fail:
45476 return NULL;
45477 }
45478
45479
45480 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45481 PyObject *resultobj = 0;
45482 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45483 wxSizer *arg2 = (wxSizer *) 0 ;
45484 void *argp1 = 0 ;
45485 int res1 = 0 ;
45486 int res2 = 0 ;
45487 PyObject * obj0 = 0 ;
45488 PyObject * obj1 = 0 ;
45489 char * kwnames[] = {
45490 (char *) "self",(char *) "sizer", NULL
45491 };
45492
45493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45495 if (!SWIG_IsOK(res1)) {
45496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45497 }
45498 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45499 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45500 if (!SWIG_IsOK(res2)) {
45501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45502 }
45503 {
45504 PyThreadState* __tstate = wxPyBeginAllowThreads();
45505 (arg1)->SetSizer(arg2);
45506 wxPyEndAllowThreads(__tstate);
45507 if (PyErr_Occurred()) SWIG_fail;
45508 }
45509 resultobj = SWIG_Py_Void();
45510 return resultobj;
45511 fail:
45512 return NULL;
45513 }
45514
45515
45516 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45517 PyObject *resultobj = 0;
45518 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45519 wxSize *result = 0 ;
45520 void *argp1 = 0 ;
45521 int res1 = 0 ;
45522 PyObject *swig_obj[1] ;
45523
45524 if (!args) SWIG_fail;
45525 swig_obj[0] = args;
45526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45527 if (!SWIG_IsOK(res1)) {
45528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45529 }
45530 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45531 {
45532 PyThreadState* __tstate = wxPyBeginAllowThreads();
45533 {
45534 wxSize const &_result_ref = (arg1)->GetSpacer();
45535 result = (wxSize *) &_result_ref;
45536 }
45537 wxPyEndAllowThreads(__tstate);
45538 if (PyErr_Occurred()) SWIG_fail;
45539 }
45540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45541 return resultobj;
45542 fail:
45543 return NULL;
45544 }
45545
45546
45547 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45548 PyObject *resultobj = 0;
45549 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45550 wxSize *arg2 = 0 ;
45551 void *argp1 = 0 ;
45552 int res1 = 0 ;
45553 wxSize temp2 ;
45554 PyObject * obj0 = 0 ;
45555 PyObject * obj1 = 0 ;
45556 char * kwnames[] = {
45557 (char *) "self",(char *) "size", NULL
45558 };
45559
45560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45562 if (!SWIG_IsOK(res1)) {
45563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45564 }
45565 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45566 {
45567 arg2 = &temp2;
45568 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45569 }
45570 {
45571 PyThreadState* __tstate = wxPyBeginAllowThreads();
45572 (arg1)->SetSpacer((wxSize const &)*arg2);
45573 wxPyEndAllowThreads(__tstate);
45574 if (PyErr_Occurred()) SWIG_fail;
45575 }
45576 resultobj = SWIG_Py_Void();
45577 return resultobj;
45578 fail:
45579 return NULL;
45580 }
45581
45582
45583 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45584 PyObject *resultobj = 0;
45585 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45586 bool arg2 ;
45587 void *argp1 = 0 ;
45588 int res1 = 0 ;
45589 bool val2 ;
45590 int ecode2 = 0 ;
45591 PyObject * obj0 = 0 ;
45592 PyObject * obj1 = 0 ;
45593 char * kwnames[] = {
45594 (char *) "self",(char *) "show", NULL
45595 };
45596
45597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45599 if (!SWIG_IsOK(res1)) {
45600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45601 }
45602 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45603 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45604 if (!SWIG_IsOK(ecode2)) {
45605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45606 }
45607 arg2 = static_cast< bool >(val2);
45608 {
45609 PyThreadState* __tstate = wxPyBeginAllowThreads();
45610 (arg1)->Show(arg2);
45611 wxPyEndAllowThreads(__tstate);
45612 if (PyErr_Occurred()) SWIG_fail;
45613 }
45614 resultobj = SWIG_Py_Void();
45615 return resultobj;
45616 fail:
45617 return NULL;
45618 }
45619
45620
45621 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45622 PyObject *resultobj = 0;
45623 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45624 bool result;
45625 void *argp1 = 0 ;
45626 int res1 = 0 ;
45627 PyObject *swig_obj[1] ;
45628
45629 if (!args) SWIG_fail;
45630 swig_obj[0] = args;
45631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45632 if (!SWIG_IsOK(res1)) {
45633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45634 }
45635 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45636 {
45637 PyThreadState* __tstate = wxPyBeginAllowThreads();
45638 result = (bool)(arg1)->IsShown();
45639 wxPyEndAllowThreads(__tstate);
45640 if (PyErr_Occurred()) SWIG_fail;
45641 }
45642 {
45643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45644 }
45645 return resultobj;
45646 fail:
45647 return NULL;
45648 }
45649
45650
45651 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45652 PyObject *resultobj = 0;
45653 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45654 wxPoint result;
45655 void *argp1 = 0 ;
45656 int res1 = 0 ;
45657 PyObject *swig_obj[1] ;
45658
45659 if (!args) SWIG_fail;
45660 swig_obj[0] = args;
45661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45662 if (!SWIG_IsOK(res1)) {
45663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45664 }
45665 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45666 {
45667 PyThreadState* __tstate = wxPyBeginAllowThreads();
45668 result = (arg1)->GetPosition();
45669 wxPyEndAllowThreads(__tstate);
45670 if (PyErr_Occurred()) SWIG_fail;
45671 }
45672 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45673 return resultobj;
45674 fail:
45675 return NULL;
45676 }
45677
45678
45679 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45680 PyObject *resultobj = 0;
45681 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45682 PyObject *result = 0 ;
45683 void *argp1 = 0 ;
45684 int res1 = 0 ;
45685 PyObject *swig_obj[1] ;
45686
45687 if (!args) SWIG_fail;
45688 swig_obj[0] = args;
45689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45690 if (!SWIG_IsOK(res1)) {
45691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45692 }
45693 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45694 {
45695 PyThreadState* __tstate = wxPyBeginAllowThreads();
45696 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45697 wxPyEndAllowThreads(__tstate);
45698 if (PyErr_Occurred()) SWIG_fail;
45699 }
45700 resultobj = result;
45701 return resultobj;
45702 fail:
45703 return NULL;
45704 }
45705
45706
45707 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45708 PyObject *resultobj = 0;
45709 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45710 PyObject *arg2 = (PyObject *) 0 ;
45711 void *argp1 = 0 ;
45712 int res1 = 0 ;
45713 PyObject * obj0 = 0 ;
45714 PyObject * obj1 = 0 ;
45715 char * kwnames[] = {
45716 (char *) "self",(char *) "userData", NULL
45717 };
45718
45719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45721 if (!SWIG_IsOK(res1)) {
45722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45723 }
45724 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45725 arg2 = obj1;
45726 {
45727 PyThreadState* __tstate = wxPyBeginAllowThreads();
45728 wxSizerItem_SetUserData(arg1,arg2);
45729 wxPyEndAllowThreads(__tstate);
45730 if (PyErr_Occurred()) SWIG_fail;
45731 }
45732 resultobj = SWIG_Py_Void();
45733 return resultobj;
45734 fail:
45735 return NULL;
45736 }
45737
45738
45739 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45740 PyObject *obj;
45741 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45742 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
45743 return SWIG_Py_Void();
45744 }
45745
45746 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45747 return SWIG_Python_InitShadowInstance(args);
45748 }
45749
45750 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45751 PyObject *resultobj = 0;
45752 wxSizer *arg1 = (wxSizer *) 0 ;
45753 void *argp1 = 0 ;
45754 int res1 = 0 ;
45755 PyObject *swig_obj[1] ;
45756
45757 if (!args) SWIG_fail;
45758 swig_obj[0] = args;
45759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45760 if (!SWIG_IsOK(res1)) {
45761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45762 }
45763 arg1 = reinterpret_cast< wxSizer * >(argp1);
45764 {
45765 PyThreadState* __tstate = wxPyBeginAllowThreads();
45766 delete arg1;
45767
45768 wxPyEndAllowThreads(__tstate);
45769 if (PyErr_Occurred()) SWIG_fail;
45770 }
45771 resultobj = SWIG_Py_Void();
45772 return resultobj;
45773 fail:
45774 return NULL;
45775 }
45776
45777
45778 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45779 PyObject *resultobj = 0;
45780 wxSizer *arg1 = (wxSizer *) 0 ;
45781 PyObject *arg2 = (PyObject *) 0 ;
45782 void *argp1 = 0 ;
45783 int res1 = 0 ;
45784 PyObject * obj0 = 0 ;
45785 PyObject * obj1 = 0 ;
45786 char * kwnames[] = {
45787 (char *) "self",(char *) "_self", NULL
45788 };
45789
45790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
45791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45792 if (!SWIG_IsOK(res1)) {
45793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
45794 }
45795 arg1 = reinterpret_cast< wxSizer * >(argp1);
45796 arg2 = obj1;
45797 {
45798 PyThreadState* __tstate = wxPyBeginAllowThreads();
45799 wxSizer__setOORInfo(arg1,arg2);
45800 wxPyEndAllowThreads(__tstate);
45801 if (PyErr_Occurred()) SWIG_fail;
45802 }
45803 resultobj = SWIG_Py_Void();
45804 return resultobj;
45805 fail:
45806 return NULL;
45807 }
45808
45809
45810 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45811 PyObject *resultobj = 0;
45812 wxSizer *arg1 = (wxSizer *) 0 ;
45813 PyObject *arg2 = (PyObject *) 0 ;
45814 int arg3 = (int) 0 ;
45815 int arg4 = (int) 0 ;
45816 int arg5 = (int) 0 ;
45817 PyObject *arg6 = (PyObject *) NULL ;
45818 wxSizerItem *result = 0 ;
45819 void *argp1 = 0 ;
45820 int res1 = 0 ;
45821 int val3 ;
45822 int ecode3 = 0 ;
45823 int val4 ;
45824 int ecode4 = 0 ;
45825 int val5 ;
45826 int ecode5 = 0 ;
45827 PyObject * obj0 = 0 ;
45828 PyObject * obj1 = 0 ;
45829 PyObject * obj2 = 0 ;
45830 PyObject * obj3 = 0 ;
45831 PyObject * obj4 = 0 ;
45832 PyObject * obj5 = 0 ;
45833 char * kwnames[] = {
45834 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45835 };
45836
45837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45839 if (!SWIG_IsOK(res1)) {
45840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
45841 }
45842 arg1 = reinterpret_cast< wxSizer * >(argp1);
45843 arg2 = obj1;
45844 if (obj2) {
45845 ecode3 = SWIG_AsVal_int(obj2, &val3);
45846 if (!SWIG_IsOK(ecode3)) {
45847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
45848 }
45849 arg3 = static_cast< int >(val3);
45850 }
45851 if (obj3) {
45852 ecode4 = SWIG_AsVal_int(obj3, &val4);
45853 if (!SWIG_IsOK(ecode4)) {
45854 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
45855 }
45856 arg4 = static_cast< int >(val4);
45857 }
45858 if (obj4) {
45859 ecode5 = SWIG_AsVal_int(obj4, &val5);
45860 if (!SWIG_IsOK(ecode5)) {
45861 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
45862 }
45863 arg5 = static_cast< int >(val5);
45864 }
45865 if (obj5) {
45866 arg6 = obj5;
45867 }
45868 {
45869 PyThreadState* __tstate = wxPyBeginAllowThreads();
45870 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
45871 wxPyEndAllowThreads(__tstate);
45872 if (PyErr_Occurred()) SWIG_fail;
45873 }
45874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
45875 return resultobj;
45876 fail:
45877 return NULL;
45878 }
45879
45880
45881 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45882 PyObject *resultobj = 0;
45883 wxSizer *arg1 = (wxSizer *) 0 ;
45884 int arg2 ;
45885 PyObject *arg3 = (PyObject *) 0 ;
45886 int arg4 = (int) 0 ;
45887 int arg5 = (int) 0 ;
45888 int arg6 = (int) 0 ;
45889 PyObject *arg7 = (PyObject *) NULL ;
45890 wxSizerItem *result = 0 ;
45891 void *argp1 = 0 ;
45892 int res1 = 0 ;
45893 int val2 ;
45894 int ecode2 = 0 ;
45895 int val4 ;
45896 int ecode4 = 0 ;
45897 int val5 ;
45898 int ecode5 = 0 ;
45899 int val6 ;
45900 int ecode6 = 0 ;
45901 PyObject * obj0 = 0 ;
45902 PyObject * obj1 = 0 ;
45903 PyObject * obj2 = 0 ;
45904 PyObject * obj3 = 0 ;
45905 PyObject * obj4 = 0 ;
45906 PyObject * obj5 = 0 ;
45907 PyObject * obj6 = 0 ;
45908 char * kwnames[] = {
45909 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45910 };
45911
45912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
45913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45914 if (!SWIG_IsOK(res1)) {
45915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
45916 }
45917 arg1 = reinterpret_cast< wxSizer * >(argp1);
45918 ecode2 = SWIG_AsVal_int(obj1, &val2);
45919 if (!SWIG_IsOK(ecode2)) {
45920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
45921 }
45922 arg2 = static_cast< int >(val2);
45923 arg3 = obj2;
45924 if (obj3) {
45925 ecode4 = SWIG_AsVal_int(obj3, &val4);
45926 if (!SWIG_IsOK(ecode4)) {
45927 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
45928 }
45929 arg4 = static_cast< int >(val4);
45930 }
45931 if (obj4) {
45932 ecode5 = SWIG_AsVal_int(obj4, &val5);
45933 if (!SWIG_IsOK(ecode5)) {
45934 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
45935 }
45936 arg5 = static_cast< int >(val5);
45937 }
45938 if (obj5) {
45939 ecode6 = SWIG_AsVal_int(obj5, &val6);
45940 if (!SWIG_IsOK(ecode6)) {
45941 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
45942 }
45943 arg6 = static_cast< int >(val6);
45944 }
45945 if (obj6) {
45946 arg7 = obj6;
45947 }
45948 {
45949 PyThreadState* __tstate = wxPyBeginAllowThreads();
45950 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
45951 wxPyEndAllowThreads(__tstate);
45952 if (PyErr_Occurred()) SWIG_fail;
45953 }
45954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
45955 return resultobj;
45956 fail:
45957 return NULL;
45958 }
45959
45960
45961 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45962 PyObject *resultobj = 0;
45963 wxSizer *arg1 = (wxSizer *) 0 ;
45964 PyObject *arg2 = (PyObject *) 0 ;
45965 int arg3 = (int) 0 ;
45966 int arg4 = (int) 0 ;
45967 int arg5 = (int) 0 ;
45968 PyObject *arg6 = (PyObject *) NULL ;
45969 wxSizerItem *result = 0 ;
45970 void *argp1 = 0 ;
45971 int res1 = 0 ;
45972 int val3 ;
45973 int ecode3 = 0 ;
45974 int val4 ;
45975 int ecode4 = 0 ;
45976 int val5 ;
45977 int ecode5 = 0 ;
45978 PyObject * obj0 = 0 ;
45979 PyObject * obj1 = 0 ;
45980 PyObject * obj2 = 0 ;
45981 PyObject * obj3 = 0 ;
45982 PyObject * obj4 = 0 ;
45983 PyObject * obj5 = 0 ;
45984 char * kwnames[] = {
45985 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45986 };
45987
45988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45990 if (!SWIG_IsOK(res1)) {
45991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
45992 }
45993 arg1 = reinterpret_cast< wxSizer * >(argp1);
45994 arg2 = obj1;
45995 if (obj2) {
45996 ecode3 = SWIG_AsVal_int(obj2, &val3);
45997 if (!SWIG_IsOK(ecode3)) {
45998 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
45999 }
46000 arg3 = static_cast< int >(val3);
46001 }
46002 if (obj3) {
46003 ecode4 = SWIG_AsVal_int(obj3, &val4);
46004 if (!SWIG_IsOK(ecode4)) {
46005 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46006 }
46007 arg4 = static_cast< int >(val4);
46008 }
46009 if (obj4) {
46010 ecode5 = SWIG_AsVal_int(obj4, &val5);
46011 if (!SWIG_IsOK(ecode5)) {
46012 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46013 }
46014 arg5 = static_cast< int >(val5);
46015 }
46016 if (obj5) {
46017 arg6 = obj5;
46018 }
46019 {
46020 PyThreadState* __tstate = wxPyBeginAllowThreads();
46021 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46022 wxPyEndAllowThreads(__tstate);
46023 if (PyErr_Occurred()) SWIG_fail;
46024 }
46025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46026 return resultobj;
46027 fail:
46028 return NULL;
46029 }
46030
46031
46032 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46033 PyObject *resultobj = 0;
46034 wxSizer *arg1 = (wxSizer *) 0 ;
46035 PyObject *arg2 = (PyObject *) 0 ;
46036 bool result;
46037 void *argp1 = 0 ;
46038 int res1 = 0 ;
46039 PyObject * obj0 = 0 ;
46040 PyObject * obj1 = 0 ;
46041 char * kwnames[] = {
46042 (char *) "self",(char *) "item", NULL
46043 };
46044
46045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46047 if (!SWIG_IsOK(res1)) {
46048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46049 }
46050 arg1 = reinterpret_cast< wxSizer * >(argp1);
46051 arg2 = obj1;
46052 {
46053 PyThreadState* __tstate = wxPyBeginAllowThreads();
46054 result = (bool)wxSizer_Remove(arg1,arg2);
46055 wxPyEndAllowThreads(__tstate);
46056 if (PyErr_Occurred()) SWIG_fail;
46057 }
46058 {
46059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46060 }
46061 return resultobj;
46062 fail:
46063 return NULL;
46064 }
46065
46066
46067 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46068 PyObject *resultobj = 0;
46069 wxSizer *arg1 = (wxSizer *) 0 ;
46070 PyObject *arg2 = (PyObject *) 0 ;
46071 bool result;
46072 void *argp1 = 0 ;
46073 int res1 = 0 ;
46074 PyObject * obj0 = 0 ;
46075 PyObject * obj1 = 0 ;
46076 char * kwnames[] = {
46077 (char *) "self",(char *) "item", NULL
46078 };
46079
46080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46082 if (!SWIG_IsOK(res1)) {
46083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46084 }
46085 arg1 = reinterpret_cast< wxSizer * >(argp1);
46086 arg2 = obj1;
46087 {
46088 PyThreadState* __tstate = wxPyBeginAllowThreads();
46089 result = (bool)wxSizer_Detach(arg1,arg2);
46090 wxPyEndAllowThreads(__tstate);
46091 if (PyErr_Occurred()) SWIG_fail;
46092 }
46093 {
46094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46095 }
46096 return resultobj;
46097 fail:
46098 return NULL;
46099 }
46100
46101
46102 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46103 PyObject *resultobj = 0;
46104 wxSizer *arg1 = (wxSizer *) 0 ;
46105 PyObject *arg2 = (PyObject *) 0 ;
46106 wxSizerItem *result = 0 ;
46107 void *argp1 = 0 ;
46108 int res1 = 0 ;
46109 PyObject * obj0 = 0 ;
46110 PyObject * obj1 = 0 ;
46111 char * kwnames[] = {
46112 (char *) "self",(char *) "item", NULL
46113 };
46114
46115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46117 if (!SWIG_IsOK(res1)) {
46118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46119 }
46120 arg1 = reinterpret_cast< wxSizer * >(argp1);
46121 arg2 = obj1;
46122 {
46123 PyThreadState* __tstate = wxPyBeginAllowThreads();
46124 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46125 wxPyEndAllowThreads(__tstate);
46126 if (PyErr_Occurred()) SWIG_fail;
46127 }
46128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46129 return resultobj;
46130 fail:
46131 return NULL;
46132 }
46133
46134
46135 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46136 PyObject *resultobj = 0;
46137 wxSizer *arg1 = (wxSizer *) 0 ;
46138 PyObject *arg2 = (PyObject *) 0 ;
46139 wxSize *arg3 = 0 ;
46140 void *argp1 = 0 ;
46141 int res1 = 0 ;
46142 wxSize temp3 ;
46143 PyObject * obj0 = 0 ;
46144 PyObject * obj1 = 0 ;
46145 PyObject * obj2 = 0 ;
46146 char * kwnames[] = {
46147 (char *) "self",(char *) "item",(char *) "size", NULL
46148 };
46149
46150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46152 if (!SWIG_IsOK(res1)) {
46153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46154 }
46155 arg1 = reinterpret_cast< wxSizer * >(argp1);
46156 arg2 = obj1;
46157 {
46158 arg3 = &temp3;
46159 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46160 }
46161 {
46162 PyThreadState* __tstate = wxPyBeginAllowThreads();
46163 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46164 wxPyEndAllowThreads(__tstate);
46165 if (PyErr_Occurred()) SWIG_fail;
46166 }
46167 resultobj = SWIG_Py_Void();
46168 return resultobj;
46169 fail:
46170 return NULL;
46171 }
46172
46173
46174 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46175 PyObject *resultobj = 0;
46176 wxSizer *arg1 = (wxSizer *) 0 ;
46177 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46178 wxSizerItem *result = 0 ;
46179 void *argp1 = 0 ;
46180 int res1 = 0 ;
46181 int res2 = 0 ;
46182 PyObject * obj0 = 0 ;
46183 PyObject * obj1 = 0 ;
46184 char * kwnames[] = {
46185 (char *) "self",(char *) "item", NULL
46186 };
46187
46188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46190 if (!SWIG_IsOK(res1)) {
46191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46192 }
46193 arg1 = reinterpret_cast< wxSizer * >(argp1);
46194 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46195 if (!SWIG_IsOK(res2)) {
46196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46197 }
46198 {
46199 PyThreadState* __tstate = wxPyBeginAllowThreads();
46200 result = (wxSizerItem *)(arg1)->Add(arg2);
46201 wxPyEndAllowThreads(__tstate);
46202 if (PyErr_Occurred()) SWIG_fail;
46203 }
46204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46205 return resultobj;
46206 fail:
46207 return NULL;
46208 }
46209
46210
46211 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46212 PyObject *resultobj = 0;
46213 wxSizer *arg1 = (wxSizer *) 0 ;
46214 size_t arg2 ;
46215 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46216 wxSizerItem *result = 0 ;
46217 void *argp1 = 0 ;
46218 int res1 = 0 ;
46219 size_t val2 ;
46220 int ecode2 = 0 ;
46221 int res3 = 0 ;
46222 PyObject * obj0 = 0 ;
46223 PyObject * obj1 = 0 ;
46224 PyObject * obj2 = 0 ;
46225 char * kwnames[] = {
46226 (char *) "self",(char *) "index",(char *) "item", NULL
46227 };
46228
46229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46231 if (!SWIG_IsOK(res1)) {
46232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46233 }
46234 arg1 = reinterpret_cast< wxSizer * >(argp1);
46235 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46236 if (!SWIG_IsOK(ecode2)) {
46237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46238 }
46239 arg2 = static_cast< size_t >(val2);
46240 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46241 if (!SWIG_IsOK(res3)) {
46242 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46243 }
46244 {
46245 PyThreadState* __tstate = wxPyBeginAllowThreads();
46246 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46247 wxPyEndAllowThreads(__tstate);
46248 if (PyErr_Occurred()) SWIG_fail;
46249 }
46250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46251 return resultobj;
46252 fail:
46253 return NULL;
46254 }
46255
46256
46257 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46258 PyObject *resultobj = 0;
46259 wxSizer *arg1 = (wxSizer *) 0 ;
46260 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46261 wxSizerItem *result = 0 ;
46262 void *argp1 = 0 ;
46263 int res1 = 0 ;
46264 int res2 = 0 ;
46265 PyObject * obj0 = 0 ;
46266 PyObject * obj1 = 0 ;
46267 char * kwnames[] = {
46268 (char *) "self",(char *) "item", NULL
46269 };
46270
46271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46273 if (!SWIG_IsOK(res1)) {
46274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46275 }
46276 arg1 = reinterpret_cast< wxSizer * >(argp1);
46277 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46278 if (!SWIG_IsOK(res2)) {
46279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46280 }
46281 {
46282 PyThreadState* __tstate = wxPyBeginAllowThreads();
46283 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46284 wxPyEndAllowThreads(__tstate);
46285 if (PyErr_Occurred()) SWIG_fail;
46286 }
46287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46288 return resultobj;
46289 fail:
46290 return NULL;
46291 }
46292
46293
46294 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46295 PyObject *resultobj = 0;
46296 wxSizer *arg1 = (wxSizer *) 0 ;
46297 int arg2 ;
46298 int arg3 ;
46299 int arg4 ;
46300 int arg5 ;
46301 void *argp1 = 0 ;
46302 int res1 = 0 ;
46303 int val2 ;
46304 int ecode2 = 0 ;
46305 int val3 ;
46306 int ecode3 = 0 ;
46307 int val4 ;
46308 int ecode4 = 0 ;
46309 int val5 ;
46310 int ecode5 = 0 ;
46311 PyObject * obj0 = 0 ;
46312 PyObject * obj1 = 0 ;
46313 PyObject * obj2 = 0 ;
46314 PyObject * obj3 = 0 ;
46315 PyObject * obj4 = 0 ;
46316 char * kwnames[] = {
46317 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46318 };
46319
46320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46322 if (!SWIG_IsOK(res1)) {
46323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46324 }
46325 arg1 = reinterpret_cast< wxSizer * >(argp1);
46326 ecode2 = SWIG_AsVal_int(obj1, &val2);
46327 if (!SWIG_IsOK(ecode2)) {
46328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46329 }
46330 arg2 = static_cast< int >(val2);
46331 ecode3 = SWIG_AsVal_int(obj2, &val3);
46332 if (!SWIG_IsOK(ecode3)) {
46333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46334 }
46335 arg3 = static_cast< int >(val3);
46336 ecode4 = SWIG_AsVal_int(obj3, &val4);
46337 if (!SWIG_IsOK(ecode4)) {
46338 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46339 }
46340 arg4 = static_cast< int >(val4);
46341 ecode5 = SWIG_AsVal_int(obj4, &val5);
46342 if (!SWIG_IsOK(ecode5)) {
46343 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46344 }
46345 arg5 = static_cast< int >(val5);
46346 {
46347 PyThreadState* __tstate = wxPyBeginAllowThreads();
46348 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46349 wxPyEndAllowThreads(__tstate);
46350 if (PyErr_Occurred()) SWIG_fail;
46351 }
46352 resultobj = SWIG_Py_Void();
46353 return resultobj;
46354 fail:
46355 return NULL;
46356 }
46357
46358
46359 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46360 PyObject *resultobj = 0;
46361 wxSizer *arg1 = (wxSizer *) 0 ;
46362 wxSize *arg2 = 0 ;
46363 void *argp1 = 0 ;
46364 int res1 = 0 ;
46365 wxSize temp2 ;
46366 PyObject * obj0 = 0 ;
46367 PyObject * obj1 = 0 ;
46368 char * kwnames[] = {
46369 (char *) "self",(char *) "size", NULL
46370 };
46371
46372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46374 if (!SWIG_IsOK(res1)) {
46375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46376 }
46377 arg1 = reinterpret_cast< wxSizer * >(argp1);
46378 {
46379 arg2 = &temp2;
46380 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46381 }
46382 {
46383 PyThreadState* __tstate = wxPyBeginAllowThreads();
46384 (arg1)->SetMinSize((wxSize const &)*arg2);
46385 wxPyEndAllowThreads(__tstate);
46386 if (PyErr_Occurred()) SWIG_fail;
46387 }
46388 resultobj = SWIG_Py_Void();
46389 return resultobj;
46390 fail:
46391 return NULL;
46392 }
46393
46394
46395 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46396 PyObject *resultobj = 0;
46397 wxSizer *arg1 = (wxSizer *) 0 ;
46398 wxSize result;
46399 void *argp1 = 0 ;
46400 int res1 = 0 ;
46401 PyObject *swig_obj[1] ;
46402
46403 if (!args) SWIG_fail;
46404 swig_obj[0] = args;
46405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46406 if (!SWIG_IsOK(res1)) {
46407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46408 }
46409 arg1 = reinterpret_cast< wxSizer * >(argp1);
46410 {
46411 PyThreadState* __tstate = wxPyBeginAllowThreads();
46412 result = (arg1)->GetSize();
46413 wxPyEndAllowThreads(__tstate);
46414 if (PyErr_Occurred()) SWIG_fail;
46415 }
46416 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46417 return resultobj;
46418 fail:
46419 return NULL;
46420 }
46421
46422
46423 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46424 PyObject *resultobj = 0;
46425 wxSizer *arg1 = (wxSizer *) 0 ;
46426 wxPoint result;
46427 void *argp1 = 0 ;
46428 int res1 = 0 ;
46429 PyObject *swig_obj[1] ;
46430
46431 if (!args) SWIG_fail;
46432 swig_obj[0] = args;
46433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46434 if (!SWIG_IsOK(res1)) {
46435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46436 }
46437 arg1 = reinterpret_cast< wxSizer * >(argp1);
46438 {
46439 PyThreadState* __tstate = wxPyBeginAllowThreads();
46440 result = (arg1)->GetPosition();
46441 wxPyEndAllowThreads(__tstate);
46442 if (PyErr_Occurred()) SWIG_fail;
46443 }
46444 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46445 return resultobj;
46446 fail:
46447 return NULL;
46448 }
46449
46450
46451 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46452 PyObject *resultobj = 0;
46453 wxSizer *arg1 = (wxSizer *) 0 ;
46454 wxSize result;
46455 void *argp1 = 0 ;
46456 int res1 = 0 ;
46457 PyObject *swig_obj[1] ;
46458
46459 if (!args) SWIG_fail;
46460 swig_obj[0] = args;
46461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46462 if (!SWIG_IsOK(res1)) {
46463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46464 }
46465 arg1 = reinterpret_cast< wxSizer * >(argp1);
46466 {
46467 PyThreadState* __tstate = wxPyBeginAllowThreads();
46468 result = (arg1)->GetMinSize();
46469 wxPyEndAllowThreads(__tstate);
46470 if (PyErr_Occurred()) SWIG_fail;
46471 }
46472 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46473 return resultobj;
46474 fail:
46475 return NULL;
46476 }
46477
46478
46479 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46480 PyObject *resultobj = 0;
46481 wxSizer *arg1 = (wxSizer *) 0 ;
46482 void *argp1 = 0 ;
46483 int res1 = 0 ;
46484 PyObject *swig_obj[1] ;
46485
46486 if (!args) SWIG_fail;
46487 swig_obj[0] = args;
46488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46489 if (!SWIG_IsOK(res1)) {
46490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46491 }
46492 arg1 = reinterpret_cast< wxSizer * >(argp1);
46493 {
46494 PyThreadState* __tstate = wxPyBeginAllowThreads();
46495 (arg1)->RecalcSizes();
46496 wxPyEndAllowThreads(__tstate);
46497 if (PyErr_Occurred()) SWIG_fail;
46498 }
46499 resultobj = SWIG_Py_Void();
46500 return resultobj;
46501 fail:
46502 return NULL;
46503 }
46504
46505
46506 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46507 PyObject *resultobj = 0;
46508 wxSizer *arg1 = (wxSizer *) 0 ;
46509 wxSize result;
46510 void *argp1 = 0 ;
46511 int res1 = 0 ;
46512 PyObject *swig_obj[1] ;
46513
46514 if (!args) SWIG_fail;
46515 swig_obj[0] = args;
46516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46517 if (!SWIG_IsOK(res1)) {
46518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46519 }
46520 arg1 = reinterpret_cast< wxSizer * >(argp1);
46521 {
46522 PyThreadState* __tstate = wxPyBeginAllowThreads();
46523 result = (arg1)->CalcMin();
46524 wxPyEndAllowThreads(__tstate);
46525 if (PyErr_Occurred()) SWIG_fail;
46526 }
46527 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46528 return resultobj;
46529 fail:
46530 return NULL;
46531 }
46532
46533
46534 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46535 PyObject *resultobj = 0;
46536 wxSizer *arg1 = (wxSizer *) 0 ;
46537 void *argp1 = 0 ;
46538 int res1 = 0 ;
46539 PyObject *swig_obj[1] ;
46540
46541 if (!args) SWIG_fail;
46542 swig_obj[0] = args;
46543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46544 if (!SWIG_IsOK(res1)) {
46545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46546 }
46547 arg1 = reinterpret_cast< wxSizer * >(argp1);
46548 {
46549 PyThreadState* __tstate = wxPyBeginAllowThreads();
46550 (arg1)->Layout();
46551 wxPyEndAllowThreads(__tstate);
46552 if (PyErr_Occurred()) SWIG_fail;
46553 }
46554 resultobj = SWIG_Py_Void();
46555 return resultobj;
46556 fail:
46557 return NULL;
46558 }
46559
46560
46561 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46562 PyObject *resultobj = 0;
46563 wxSizer *arg1 = (wxSizer *) 0 ;
46564 wxWindow *arg2 = (wxWindow *) 0 ;
46565 wxSize result;
46566 void *argp1 = 0 ;
46567 int res1 = 0 ;
46568 void *argp2 = 0 ;
46569 int res2 = 0 ;
46570 PyObject * obj0 = 0 ;
46571 PyObject * obj1 = 0 ;
46572 char * kwnames[] = {
46573 (char *) "self",(char *) "window", NULL
46574 };
46575
46576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46578 if (!SWIG_IsOK(res1)) {
46579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46580 }
46581 arg1 = reinterpret_cast< wxSizer * >(argp1);
46582 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46583 if (!SWIG_IsOK(res2)) {
46584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46585 }
46586 arg2 = reinterpret_cast< wxWindow * >(argp2);
46587 {
46588 PyThreadState* __tstate = wxPyBeginAllowThreads();
46589 result = (arg1)->Fit(arg2);
46590 wxPyEndAllowThreads(__tstate);
46591 if (PyErr_Occurred()) SWIG_fail;
46592 }
46593 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46594 return resultobj;
46595 fail:
46596 return NULL;
46597 }
46598
46599
46600 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46601 PyObject *resultobj = 0;
46602 wxSizer *arg1 = (wxSizer *) 0 ;
46603 wxWindow *arg2 = (wxWindow *) 0 ;
46604 void *argp1 = 0 ;
46605 int res1 = 0 ;
46606 void *argp2 = 0 ;
46607 int res2 = 0 ;
46608 PyObject * obj0 = 0 ;
46609 PyObject * obj1 = 0 ;
46610 char * kwnames[] = {
46611 (char *) "self",(char *) "window", NULL
46612 };
46613
46614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46616 if (!SWIG_IsOK(res1)) {
46617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46618 }
46619 arg1 = reinterpret_cast< wxSizer * >(argp1);
46620 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46621 if (!SWIG_IsOK(res2)) {
46622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46623 }
46624 arg2 = reinterpret_cast< wxWindow * >(argp2);
46625 {
46626 PyThreadState* __tstate = wxPyBeginAllowThreads();
46627 (arg1)->FitInside(arg2);
46628 wxPyEndAllowThreads(__tstate);
46629 if (PyErr_Occurred()) SWIG_fail;
46630 }
46631 resultobj = SWIG_Py_Void();
46632 return resultobj;
46633 fail:
46634 return NULL;
46635 }
46636
46637
46638 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46639 PyObject *resultobj = 0;
46640 wxSizer *arg1 = (wxSizer *) 0 ;
46641 wxWindow *arg2 = (wxWindow *) 0 ;
46642 void *argp1 = 0 ;
46643 int res1 = 0 ;
46644 void *argp2 = 0 ;
46645 int res2 = 0 ;
46646 PyObject * obj0 = 0 ;
46647 PyObject * obj1 = 0 ;
46648 char * kwnames[] = {
46649 (char *) "self",(char *) "window", NULL
46650 };
46651
46652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46654 if (!SWIG_IsOK(res1)) {
46655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46656 }
46657 arg1 = reinterpret_cast< wxSizer * >(argp1);
46658 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46659 if (!SWIG_IsOK(res2)) {
46660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46661 }
46662 arg2 = reinterpret_cast< wxWindow * >(argp2);
46663 {
46664 PyThreadState* __tstate = wxPyBeginAllowThreads();
46665 (arg1)->SetSizeHints(arg2);
46666 wxPyEndAllowThreads(__tstate);
46667 if (PyErr_Occurred()) SWIG_fail;
46668 }
46669 resultobj = SWIG_Py_Void();
46670 return resultobj;
46671 fail:
46672 return NULL;
46673 }
46674
46675
46676 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46677 PyObject *resultobj = 0;
46678 wxSizer *arg1 = (wxSizer *) 0 ;
46679 wxWindow *arg2 = (wxWindow *) 0 ;
46680 void *argp1 = 0 ;
46681 int res1 = 0 ;
46682 void *argp2 = 0 ;
46683 int res2 = 0 ;
46684 PyObject * obj0 = 0 ;
46685 PyObject * obj1 = 0 ;
46686 char * kwnames[] = {
46687 (char *) "self",(char *) "window", NULL
46688 };
46689
46690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46692 if (!SWIG_IsOK(res1)) {
46693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46694 }
46695 arg1 = reinterpret_cast< wxSizer * >(argp1);
46696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46697 if (!SWIG_IsOK(res2)) {
46698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46699 }
46700 arg2 = reinterpret_cast< wxWindow * >(argp2);
46701 {
46702 PyThreadState* __tstate = wxPyBeginAllowThreads();
46703 (arg1)->SetVirtualSizeHints(arg2);
46704 wxPyEndAllowThreads(__tstate);
46705 if (PyErr_Occurred()) SWIG_fail;
46706 }
46707 resultobj = SWIG_Py_Void();
46708 return resultobj;
46709 fail:
46710 return NULL;
46711 }
46712
46713
46714 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46715 PyObject *resultobj = 0;
46716 wxSizer *arg1 = (wxSizer *) 0 ;
46717 bool arg2 = (bool) false ;
46718 void *argp1 = 0 ;
46719 int res1 = 0 ;
46720 bool val2 ;
46721 int ecode2 = 0 ;
46722 PyObject * obj0 = 0 ;
46723 PyObject * obj1 = 0 ;
46724 char * kwnames[] = {
46725 (char *) "self",(char *) "deleteWindows", NULL
46726 };
46727
46728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
46729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46730 if (!SWIG_IsOK(res1)) {
46731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
46732 }
46733 arg1 = reinterpret_cast< wxSizer * >(argp1);
46734 if (obj1) {
46735 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46736 if (!SWIG_IsOK(ecode2)) {
46737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
46738 }
46739 arg2 = static_cast< bool >(val2);
46740 }
46741 {
46742 PyThreadState* __tstate = wxPyBeginAllowThreads();
46743 (arg1)->Clear(arg2);
46744 wxPyEndAllowThreads(__tstate);
46745 if (PyErr_Occurred()) SWIG_fail;
46746 }
46747 resultobj = SWIG_Py_Void();
46748 return resultobj;
46749 fail:
46750 return NULL;
46751 }
46752
46753
46754 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46755 PyObject *resultobj = 0;
46756 wxSizer *arg1 = (wxSizer *) 0 ;
46757 void *argp1 = 0 ;
46758 int res1 = 0 ;
46759 PyObject *swig_obj[1] ;
46760
46761 if (!args) SWIG_fail;
46762 swig_obj[0] = args;
46763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46764 if (!SWIG_IsOK(res1)) {
46765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
46766 }
46767 arg1 = reinterpret_cast< wxSizer * >(argp1);
46768 {
46769 PyThreadState* __tstate = wxPyBeginAllowThreads();
46770 (arg1)->DeleteWindows();
46771 wxPyEndAllowThreads(__tstate);
46772 if (PyErr_Occurred()) SWIG_fail;
46773 }
46774 resultobj = SWIG_Py_Void();
46775 return resultobj;
46776 fail:
46777 return NULL;
46778 }
46779
46780
46781 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46782 PyObject *resultobj = 0;
46783 wxSizer *arg1 = (wxSizer *) 0 ;
46784 PyObject *result = 0 ;
46785 void *argp1 = 0 ;
46786 int res1 = 0 ;
46787 PyObject *swig_obj[1] ;
46788
46789 if (!args) SWIG_fail;
46790 swig_obj[0] = args;
46791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46792 if (!SWIG_IsOK(res1)) {
46793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
46794 }
46795 arg1 = reinterpret_cast< wxSizer * >(argp1);
46796 {
46797 PyThreadState* __tstate = wxPyBeginAllowThreads();
46798 result = (PyObject *)wxSizer_GetChildren(arg1);
46799 wxPyEndAllowThreads(__tstate);
46800 if (PyErr_Occurred()) SWIG_fail;
46801 }
46802 resultobj = result;
46803 return resultobj;
46804 fail:
46805 return NULL;
46806 }
46807
46808
46809 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46810 PyObject *resultobj = 0;
46811 wxSizer *arg1 = (wxSizer *) 0 ;
46812 PyObject *arg2 = (PyObject *) 0 ;
46813 bool arg3 = (bool) true ;
46814 bool arg4 = (bool) false ;
46815 bool result;
46816 void *argp1 = 0 ;
46817 int res1 = 0 ;
46818 bool val3 ;
46819 int ecode3 = 0 ;
46820 bool val4 ;
46821 int ecode4 = 0 ;
46822 PyObject * obj0 = 0 ;
46823 PyObject * obj1 = 0 ;
46824 PyObject * obj2 = 0 ;
46825 PyObject * obj3 = 0 ;
46826 char * kwnames[] = {
46827 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
46828 };
46829
46830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
46831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46832 if (!SWIG_IsOK(res1)) {
46833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
46834 }
46835 arg1 = reinterpret_cast< wxSizer * >(argp1);
46836 arg2 = obj1;
46837 if (obj2) {
46838 ecode3 = SWIG_AsVal_bool(obj2, &val3);
46839 if (!SWIG_IsOK(ecode3)) {
46840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
46841 }
46842 arg3 = static_cast< bool >(val3);
46843 }
46844 if (obj3) {
46845 ecode4 = SWIG_AsVal_bool(obj3, &val4);
46846 if (!SWIG_IsOK(ecode4)) {
46847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
46848 }
46849 arg4 = static_cast< bool >(val4);
46850 }
46851 {
46852 PyThreadState* __tstate = wxPyBeginAllowThreads();
46853 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
46854 wxPyEndAllowThreads(__tstate);
46855 if (PyErr_Occurred()) SWIG_fail;
46856 }
46857 {
46858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46859 }
46860 return resultobj;
46861 fail:
46862 return NULL;
46863 }
46864
46865
46866 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46867 PyObject *resultobj = 0;
46868 wxSizer *arg1 = (wxSizer *) 0 ;
46869 PyObject *arg2 = (PyObject *) 0 ;
46870 bool result;
46871 void *argp1 = 0 ;
46872 int res1 = 0 ;
46873 PyObject * obj0 = 0 ;
46874 PyObject * obj1 = 0 ;
46875 char * kwnames[] = {
46876 (char *) "self",(char *) "item", NULL
46877 };
46878
46879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
46880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46881 if (!SWIG_IsOK(res1)) {
46882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
46883 }
46884 arg1 = reinterpret_cast< wxSizer * >(argp1);
46885 arg2 = obj1;
46886 {
46887 PyThreadState* __tstate = wxPyBeginAllowThreads();
46888 result = (bool)wxSizer_IsShown(arg1,arg2);
46889 wxPyEndAllowThreads(__tstate);
46890 if (PyErr_Occurred()) SWIG_fail;
46891 }
46892 {
46893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46894 }
46895 return resultobj;
46896 fail:
46897 return NULL;
46898 }
46899
46900
46901 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46902 PyObject *resultobj = 0;
46903 wxSizer *arg1 = (wxSizer *) 0 ;
46904 bool arg2 ;
46905 void *argp1 = 0 ;
46906 int res1 = 0 ;
46907 bool val2 ;
46908 int ecode2 = 0 ;
46909 PyObject * obj0 = 0 ;
46910 PyObject * obj1 = 0 ;
46911 char * kwnames[] = {
46912 (char *) "self",(char *) "show", NULL
46913 };
46914
46915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
46916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46917 if (!SWIG_IsOK(res1)) {
46918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
46919 }
46920 arg1 = reinterpret_cast< wxSizer * >(argp1);
46921 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46922 if (!SWIG_IsOK(ecode2)) {
46923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
46924 }
46925 arg2 = static_cast< bool >(val2);
46926 {
46927 PyThreadState* __tstate = wxPyBeginAllowThreads();
46928 (arg1)->ShowItems(arg2);
46929 wxPyEndAllowThreads(__tstate);
46930 if (PyErr_Occurred()) SWIG_fail;
46931 }
46932 resultobj = SWIG_Py_Void();
46933 return resultobj;
46934 fail:
46935 return NULL;
46936 }
46937
46938
46939 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46940 PyObject *obj;
46941 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46942 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
46943 return SWIG_Py_Void();
46944 }
46945
46946 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46947 PyObject *resultobj = 0;
46948 wxPySizer *result = 0 ;
46949
46950 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
46951 {
46952 PyThreadState* __tstate = wxPyBeginAllowThreads();
46953 result = (wxPySizer *)new wxPySizer();
46954 wxPyEndAllowThreads(__tstate);
46955 if (PyErr_Occurred()) SWIG_fail;
46956 }
46957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
46958 return resultobj;
46959 fail:
46960 return NULL;
46961 }
46962
46963
46964 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46965 PyObject *resultobj = 0;
46966 wxPySizer *arg1 = (wxPySizer *) 0 ;
46967 PyObject *arg2 = (PyObject *) 0 ;
46968 PyObject *arg3 = (PyObject *) 0 ;
46969 void *argp1 = 0 ;
46970 int res1 = 0 ;
46971 PyObject * obj0 = 0 ;
46972 PyObject * obj1 = 0 ;
46973 PyObject * obj2 = 0 ;
46974 char * kwnames[] = {
46975 (char *) "self",(char *) "self",(char *) "_class", NULL
46976 };
46977
46978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
46980 if (!SWIG_IsOK(res1)) {
46981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
46982 }
46983 arg1 = reinterpret_cast< wxPySizer * >(argp1);
46984 arg2 = obj1;
46985 arg3 = obj2;
46986 {
46987 PyThreadState* __tstate = wxPyBeginAllowThreads();
46988 (arg1)->_setCallbackInfo(arg2,arg3);
46989 wxPyEndAllowThreads(__tstate);
46990 if (PyErr_Occurred()) SWIG_fail;
46991 }
46992 resultobj = SWIG_Py_Void();
46993 return resultobj;
46994 fail:
46995 return NULL;
46996 }
46997
46998
46999 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47000 PyObject *obj;
47001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47002 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47003 return SWIG_Py_Void();
47004 }
47005
47006 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47007 return SWIG_Python_InitShadowInstance(args);
47008 }
47009
47010 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47011 PyObject *resultobj = 0;
47012 int arg1 = (int) wxHORIZONTAL ;
47013 wxBoxSizer *result = 0 ;
47014 int val1 ;
47015 int ecode1 = 0 ;
47016 PyObject * obj0 = 0 ;
47017 char * kwnames[] = {
47018 (char *) "orient", NULL
47019 };
47020
47021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47022 if (obj0) {
47023 ecode1 = SWIG_AsVal_int(obj0, &val1);
47024 if (!SWIG_IsOK(ecode1)) {
47025 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47026 }
47027 arg1 = static_cast< int >(val1);
47028 }
47029 {
47030 PyThreadState* __tstate = wxPyBeginAllowThreads();
47031 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47032 wxPyEndAllowThreads(__tstate);
47033 if (PyErr_Occurred()) SWIG_fail;
47034 }
47035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47036 return resultobj;
47037 fail:
47038 return NULL;
47039 }
47040
47041
47042 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47043 PyObject *resultobj = 0;
47044 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47045 int result;
47046 void *argp1 = 0 ;
47047 int res1 = 0 ;
47048 PyObject *swig_obj[1] ;
47049
47050 if (!args) SWIG_fail;
47051 swig_obj[0] = args;
47052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47053 if (!SWIG_IsOK(res1)) {
47054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47055 }
47056 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47057 {
47058 PyThreadState* __tstate = wxPyBeginAllowThreads();
47059 result = (int)(arg1)->GetOrientation();
47060 wxPyEndAllowThreads(__tstate);
47061 if (PyErr_Occurred()) SWIG_fail;
47062 }
47063 resultobj = SWIG_From_int(static_cast< int >(result));
47064 return resultobj;
47065 fail:
47066 return NULL;
47067 }
47068
47069
47070 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47071 PyObject *resultobj = 0;
47072 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47073 int arg2 ;
47074 void *argp1 = 0 ;
47075 int res1 = 0 ;
47076 int val2 ;
47077 int ecode2 = 0 ;
47078 PyObject * obj0 = 0 ;
47079 PyObject * obj1 = 0 ;
47080 char * kwnames[] = {
47081 (char *) "self",(char *) "orient", NULL
47082 };
47083
47084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47086 if (!SWIG_IsOK(res1)) {
47087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47088 }
47089 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47090 ecode2 = SWIG_AsVal_int(obj1, &val2);
47091 if (!SWIG_IsOK(ecode2)) {
47092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47093 }
47094 arg2 = static_cast< int >(val2);
47095 {
47096 PyThreadState* __tstate = wxPyBeginAllowThreads();
47097 (arg1)->SetOrientation(arg2);
47098 wxPyEndAllowThreads(__tstate);
47099 if (PyErr_Occurred()) SWIG_fail;
47100 }
47101 resultobj = SWIG_Py_Void();
47102 return resultobj;
47103 fail:
47104 return NULL;
47105 }
47106
47107
47108 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47109 PyObject *obj;
47110 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47111 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47112 return SWIG_Py_Void();
47113 }
47114
47115 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47116 return SWIG_Python_InitShadowInstance(args);
47117 }
47118
47119 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47120 PyObject *resultobj = 0;
47121 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47122 int arg2 = (int) wxHORIZONTAL ;
47123 wxStaticBoxSizer *result = 0 ;
47124 void *argp1 = 0 ;
47125 int res1 = 0 ;
47126 int val2 ;
47127 int ecode2 = 0 ;
47128 PyObject * obj0 = 0 ;
47129 PyObject * obj1 = 0 ;
47130 char * kwnames[] = {
47131 (char *) "box",(char *) "orient", NULL
47132 };
47133
47134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47136 if (!SWIG_IsOK(res1)) {
47137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47138 }
47139 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47140 if (obj1) {
47141 ecode2 = SWIG_AsVal_int(obj1, &val2);
47142 if (!SWIG_IsOK(ecode2)) {
47143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47144 }
47145 arg2 = static_cast< int >(val2);
47146 }
47147 {
47148 PyThreadState* __tstate = wxPyBeginAllowThreads();
47149 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47150 wxPyEndAllowThreads(__tstate);
47151 if (PyErr_Occurred()) SWIG_fail;
47152 }
47153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47154 return resultobj;
47155 fail:
47156 return NULL;
47157 }
47158
47159
47160 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47161 PyObject *resultobj = 0;
47162 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47163 wxStaticBox *result = 0 ;
47164 void *argp1 = 0 ;
47165 int res1 = 0 ;
47166 PyObject *swig_obj[1] ;
47167
47168 if (!args) SWIG_fail;
47169 swig_obj[0] = args;
47170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47171 if (!SWIG_IsOK(res1)) {
47172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47173 }
47174 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47175 {
47176 PyThreadState* __tstate = wxPyBeginAllowThreads();
47177 result = (wxStaticBox *)(arg1)->GetStaticBox();
47178 wxPyEndAllowThreads(__tstate);
47179 if (PyErr_Occurred()) SWIG_fail;
47180 }
47181 {
47182 resultobj = wxPyMake_wxObject(result, (bool)0);
47183 }
47184 return resultobj;
47185 fail:
47186 return NULL;
47187 }
47188
47189
47190 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47191 PyObject *obj;
47192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47193 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47194 return SWIG_Py_Void();
47195 }
47196
47197 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47198 return SWIG_Python_InitShadowInstance(args);
47199 }
47200
47201 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47202 PyObject *resultobj = 0;
47203 int arg1 = (int) 1 ;
47204 int arg2 = (int) 0 ;
47205 int arg3 = (int) 0 ;
47206 int arg4 = (int) 0 ;
47207 wxGridSizer *result = 0 ;
47208 int val1 ;
47209 int ecode1 = 0 ;
47210 int val2 ;
47211 int ecode2 = 0 ;
47212 int val3 ;
47213 int ecode3 = 0 ;
47214 int val4 ;
47215 int ecode4 = 0 ;
47216 PyObject * obj0 = 0 ;
47217 PyObject * obj1 = 0 ;
47218 PyObject * obj2 = 0 ;
47219 PyObject * obj3 = 0 ;
47220 char * kwnames[] = {
47221 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47222 };
47223
47224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47225 if (obj0) {
47226 ecode1 = SWIG_AsVal_int(obj0, &val1);
47227 if (!SWIG_IsOK(ecode1)) {
47228 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47229 }
47230 arg1 = static_cast< int >(val1);
47231 }
47232 if (obj1) {
47233 ecode2 = SWIG_AsVal_int(obj1, &val2);
47234 if (!SWIG_IsOK(ecode2)) {
47235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47236 }
47237 arg2 = static_cast< int >(val2);
47238 }
47239 if (obj2) {
47240 ecode3 = SWIG_AsVal_int(obj2, &val3);
47241 if (!SWIG_IsOK(ecode3)) {
47242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47243 }
47244 arg3 = static_cast< int >(val3);
47245 }
47246 if (obj3) {
47247 ecode4 = SWIG_AsVal_int(obj3, &val4);
47248 if (!SWIG_IsOK(ecode4)) {
47249 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47250 }
47251 arg4 = static_cast< int >(val4);
47252 }
47253 {
47254 PyThreadState* __tstate = wxPyBeginAllowThreads();
47255 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47256 wxPyEndAllowThreads(__tstate);
47257 if (PyErr_Occurred()) SWIG_fail;
47258 }
47259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47260 return resultobj;
47261 fail:
47262 return NULL;
47263 }
47264
47265
47266 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47267 PyObject *resultobj = 0;
47268 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47269 int arg2 ;
47270 void *argp1 = 0 ;
47271 int res1 = 0 ;
47272 int val2 ;
47273 int ecode2 = 0 ;
47274 PyObject * obj0 = 0 ;
47275 PyObject * obj1 = 0 ;
47276 char * kwnames[] = {
47277 (char *) "self",(char *) "cols", NULL
47278 };
47279
47280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47282 if (!SWIG_IsOK(res1)) {
47283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47284 }
47285 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47286 ecode2 = SWIG_AsVal_int(obj1, &val2);
47287 if (!SWIG_IsOK(ecode2)) {
47288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47289 }
47290 arg2 = static_cast< int >(val2);
47291 {
47292 PyThreadState* __tstate = wxPyBeginAllowThreads();
47293 (arg1)->SetCols(arg2);
47294 wxPyEndAllowThreads(__tstate);
47295 if (PyErr_Occurred()) SWIG_fail;
47296 }
47297 resultobj = SWIG_Py_Void();
47298 return resultobj;
47299 fail:
47300 return NULL;
47301 }
47302
47303
47304 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47305 PyObject *resultobj = 0;
47306 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47307 int arg2 ;
47308 void *argp1 = 0 ;
47309 int res1 = 0 ;
47310 int val2 ;
47311 int ecode2 = 0 ;
47312 PyObject * obj0 = 0 ;
47313 PyObject * obj1 = 0 ;
47314 char * kwnames[] = {
47315 (char *) "self",(char *) "rows", NULL
47316 };
47317
47318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47320 if (!SWIG_IsOK(res1)) {
47321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47322 }
47323 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47324 ecode2 = SWIG_AsVal_int(obj1, &val2);
47325 if (!SWIG_IsOK(ecode2)) {
47326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47327 }
47328 arg2 = static_cast< int >(val2);
47329 {
47330 PyThreadState* __tstate = wxPyBeginAllowThreads();
47331 (arg1)->SetRows(arg2);
47332 wxPyEndAllowThreads(__tstate);
47333 if (PyErr_Occurred()) SWIG_fail;
47334 }
47335 resultobj = SWIG_Py_Void();
47336 return resultobj;
47337 fail:
47338 return NULL;
47339 }
47340
47341
47342 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47343 PyObject *resultobj = 0;
47344 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47345 int arg2 ;
47346 void *argp1 = 0 ;
47347 int res1 = 0 ;
47348 int val2 ;
47349 int ecode2 = 0 ;
47350 PyObject * obj0 = 0 ;
47351 PyObject * obj1 = 0 ;
47352 char * kwnames[] = {
47353 (char *) "self",(char *) "gap", NULL
47354 };
47355
47356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47358 if (!SWIG_IsOK(res1)) {
47359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47360 }
47361 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47362 ecode2 = SWIG_AsVal_int(obj1, &val2);
47363 if (!SWIG_IsOK(ecode2)) {
47364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47365 }
47366 arg2 = static_cast< int >(val2);
47367 {
47368 PyThreadState* __tstate = wxPyBeginAllowThreads();
47369 (arg1)->SetVGap(arg2);
47370 wxPyEndAllowThreads(__tstate);
47371 if (PyErr_Occurred()) SWIG_fail;
47372 }
47373 resultobj = SWIG_Py_Void();
47374 return resultobj;
47375 fail:
47376 return NULL;
47377 }
47378
47379
47380 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47381 PyObject *resultobj = 0;
47382 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47383 int arg2 ;
47384 void *argp1 = 0 ;
47385 int res1 = 0 ;
47386 int val2 ;
47387 int ecode2 = 0 ;
47388 PyObject * obj0 = 0 ;
47389 PyObject * obj1 = 0 ;
47390 char * kwnames[] = {
47391 (char *) "self",(char *) "gap", NULL
47392 };
47393
47394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47396 if (!SWIG_IsOK(res1)) {
47397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47398 }
47399 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47400 ecode2 = SWIG_AsVal_int(obj1, &val2);
47401 if (!SWIG_IsOK(ecode2)) {
47402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47403 }
47404 arg2 = static_cast< int >(val2);
47405 {
47406 PyThreadState* __tstate = wxPyBeginAllowThreads();
47407 (arg1)->SetHGap(arg2);
47408 wxPyEndAllowThreads(__tstate);
47409 if (PyErr_Occurred()) SWIG_fail;
47410 }
47411 resultobj = SWIG_Py_Void();
47412 return resultobj;
47413 fail:
47414 return NULL;
47415 }
47416
47417
47418 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47419 PyObject *resultobj = 0;
47420 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47421 int result;
47422 void *argp1 = 0 ;
47423 int res1 = 0 ;
47424 PyObject *swig_obj[1] ;
47425
47426 if (!args) SWIG_fail;
47427 swig_obj[0] = args;
47428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47429 if (!SWIG_IsOK(res1)) {
47430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47431 }
47432 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47433 {
47434 PyThreadState* __tstate = wxPyBeginAllowThreads();
47435 result = (int)(arg1)->GetCols();
47436 wxPyEndAllowThreads(__tstate);
47437 if (PyErr_Occurred()) SWIG_fail;
47438 }
47439 resultobj = SWIG_From_int(static_cast< int >(result));
47440 return resultobj;
47441 fail:
47442 return NULL;
47443 }
47444
47445
47446 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47447 PyObject *resultobj = 0;
47448 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47449 int result;
47450 void *argp1 = 0 ;
47451 int res1 = 0 ;
47452 PyObject *swig_obj[1] ;
47453
47454 if (!args) SWIG_fail;
47455 swig_obj[0] = args;
47456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47457 if (!SWIG_IsOK(res1)) {
47458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47459 }
47460 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47461 {
47462 PyThreadState* __tstate = wxPyBeginAllowThreads();
47463 result = (int)(arg1)->GetRows();
47464 wxPyEndAllowThreads(__tstate);
47465 if (PyErr_Occurred()) SWIG_fail;
47466 }
47467 resultobj = SWIG_From_int(static_cast< int >(result));
47468 return resultobj;
47469 fail:
47470 return NULL;
47471 }
47472
47473
47474 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47475 PyObject *resultobj = 0;
47476 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47477 int result;
47478 void *argp1 = 0 ;
47479 int res1 = 0 ;
47480 PyObject *swig_obj[1] ;
47481
47482 if (!args) SWIG_fail;
47483 swig_obj[0] = args;
47484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47485 if (!SWIG_IsOK(res1)) {
47486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47487 }
47488 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47489 {
47490 PyThreadState* __tstate = wxPyBeginAllowThreads();
47491 result = (int)(arg1)->GetVGap();
47492 wxPyEndAllowThreads(__tstate);
47493 if (PyErr_Occurred()) SWIG_fail;
47494 }
47495 resultobj = SWIG_From_int(static_cast< int >(result));
47496 return resultobj;
47497 fail:
47498 return NULL;
47499 }
47500
47501
47502 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47503 PyObject *resultobj = 0;
47504 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47505 int result;
47506 void *argp1 = 0 ;
47507 int res1 = 0 ;
47508 PyObject *swig_obj[1] ;
47509
47510 if (!args) SWIG_fail;
47511 swig_obj[0] = args;
47512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47513 if (!SWIG_IsOK(res1)) {
47514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47515 }
47516 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47517 {
47518 PyThreadState* __tstate = wxPyBeginAllowThreads();
47519 result = (int)(arg1)->GetHGap();
47520 wxPyEndAllowThreads(__tstate);
47521 if (PyErr_Occurred()) SWIG_fail;
47522 }
47523 resultobj = SWIG_From_int(static_cast< int >(result));
47524 return resultobj;
47525 fail:
47526 return NULL;
47527 }
47528
47529
47530 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47531 PyObject *obj;
47532 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47533 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47534 return SWIG_Py_Void();
47535 }
47536
47537 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47538 return SWIG_Python_InitShadowInstance(args);
47539 }
47540
47541 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47542 PyObject *resultobj = 0;
47543 int arg1 = (int) 1 ;
47544 int arg2 = (int) 0 ;
47545 int arg3 = (int) 0 ;
47546 int arg4 = (int) 0 ;
47547 wxFlexGridSizer *result = 0 ;
47548 int val1 ;
47549 int ecode1 = 0 ;
47550 int val2 ;
47551 int ecode2 = 0 ;
47552 int val3 ;
47553 int ecode3 = 0 ;
47554 int val4 ;
47555 int ecode4 = 0 ;
47556 PyObject * obj0 = 0 ;
47557 PyObject * obj1 = 0 ;
47558 PyObject * obj2 = 0 ;
47559 PyObject * obj3 = 0 ;
47560 char * kwnames[] = {
47561 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47562 };
47563
47564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47565 if (obj0) {
47566 ecode1 = SWIG_AsVal_int(obj0, &val1);
47567 if (!SWIG_IsOK(ecode1)) {
47568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47569 }
47570 arg1 = static_cast< int >(val1);
47571 }
47572 if (obj1) {
47573 ecode2 = SWIG_AsVal_int(obj1, &val2);
47574 if (!SWIG_IsOK(ecode2)) {
47575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47576 }
47577 arg2 = static_cast< int >(val2);
47578 }
47579 if (obj2) {
47580 ecode3 = SWIG_AsVal_int(obj2, &val3);
47581 if (!SWIG_IsOK(ecode3)) {
47582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47583 }
47584 arg3 = static_cast< int >(val3);
47585 }
47586 if (obj3) {
47587 ecode4 = SWIG_AsVal_int(obj3, &val4);
47588 if (!SWIG_IsOK(ecode4)) {
47589 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47590 }
47591 arg4 = static_cast< int >(val4);
47592 }
47593 {
47594 PyThreadState* __tstate = wxPyBeginAllowThreads();
47595 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47596 wxPyEndAllowThreads(__tstate);
47597 if (PyErr_Occurred()) SWIG_fail;
47598 }
47599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47600 return resultobj;
47601 fail:
47602 return NULL;
47603 }
47604
47605
47606 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47607 PyObject *resultobj = 0;
47608 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47609 size_t arg2 ;
47610 int arg3 = (int) 0 ;
47611 void *argp1 = 0 ;
47612 int res1 = 0 ;
47613 size_t val2 ;
47614 int ecode2 = 0 ;
47615 int val3 ;
47616 int ecode3 = 0 ;
47617 PyObject * obj0 = 0 ;
47618 PyObject * obj1 = 0 ;
47619 PyObject * obj2 = 0 ;
47620 char * kwnames[] = {
47621 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47622 };
47623
47624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47626 if (!SWIG_IsOK(res1)) {
47627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47628 }
47629 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47630 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47631 if (!SWIG_IsOK(ecode2)) {
47632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47633 }
47634 arg2 = static_cast< size_t >(val2);
47635 if (obj2) {
47636 ecode3 = SWIG_AsVal_int(obj2, &val3);
47637 if (!SWIG_IsOK(ecode3)) {
47638 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47639 }
47640 arg3 = static_cast< int >(val3);
47641 }
47642 {
47643 PyThreadState* __tstate = wxPyBeginAllowThreads();
47644 (arg1)->AddGrowableRow(arg2,arg3);
47645 wxPyEndAllowThreads(__tstate);
47646 if (PyErr_Occurred()) SWIG_fail;
47647 }
47648 resultobj = SWIG_Py_Void();
47649 return resultobj;
47650 fail:
47651 return NULL;
47652 }
47653
47654
47655 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47656 PyObject *resultobj = 0;
47657 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47658 size_t arg2 ;
47659 void *argp1 = 0 ;
47660 int res1 = 0 ;
47661 size_t val2 ;
47662 int ecode2 = 0 ;
47663 PyObject * obj0 = 0 ;
47664 PyObject * obj1 = 0 ;
47665 char * kwnames[] = {
47666 (char *) "self",(char *) "idx", NULL
47667 };
47668
47669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47671 if (!SWIG_IsOK(res1)) {
47672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47673 }
47674 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47675 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47676 if (!SWIG_IsOK(ecode2)) {
47677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47678 }
47679 arg2 = static_cast< size_t >(val2);
47680 {
47681 PyThreadState* __tstate = wxPyBeginAllowThreads();
47682 (arg1)->RemoveGrowableRow(arg2);
47683 wxPyEndAllowThreads(__tstate);
47684 if (PyErr_Occurred()) SWIG_fail;
47685 }
47686 resultobj = SWIG_Py_Void();
47687 return resultobj;
47688 fail:
47689 return NULL;
47690 }
47691
47692
47693 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47694 PyObject *resultobj = 0;
47695 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47696 size_t arg2 ;
47697 int arg3 = (int) 0 ;
47698 void *argp1 = 0 ;
47699 int res1 = 0 ;
47700 size_t val2 ;
47701 int ecode2 = 0 ;
47702 int val3 ;
47703 int ecode3 = 0 ;
47704 PyObject * obj0 = 0 ;
47705 PyObject * obj1 = 0 ;
47706 PyObject * obj2 = 0 ;
47707 char * kwnames[] = {
47708 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47709 };
47710
47711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47713 if (!SWIG_IsOK(res1)) {
47714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47715 }
47716 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47717 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47718 if (!SWIG_IsOK(ecode2)) {
47719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47720 }
47721 arg2 = static_cast< size_t >(val2);
47722 if (obj2) {
47723 ecode3 = SWIG_AsVal_int(obj2, &val3);
47724 if (!SWIG_IsOK(ecode3)) {
47725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47726 }
47727 arg3 = static_cast< int >(val3);
47728 }
47729 {
47730 PyThreadState* __tstate = wxPyBeginAllowThreads();
47731 (arg1)->AddGrowableCol(arg2,arg3);
47732 wxPyEndAllowThreads(__tstate);
47733 if (PyErr_Occurred()) SWIG_fail;
47734 }
47735 resultobj = SWIG_Py_Void();
47736 return resultobj;
47737 fail:
47738 return NULL;
47739 }
47740
47741
47742 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47743 PyObject *resultobj = 0;
47744 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47745 size_t arg2 ;
47746 void *argp1 = 0 ;
47747 int res1 = 0 ;
47748 size_t val2 ;
47749 int ecode2 = 0 ;
47750 PyObject * obj0 = 0 ;
47751 PyObject * obj1 = 0 ;
47752 char * kwnames[] = {
47753 (char *) "self",(char *) "idx", NULL
47754 };
47755
47756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
47757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47758 if (!SWIG_IsOK(res1)) {
47759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47760 }
47761 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47762 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47763 if (!SWIG_IsOK(ecode2)) {
47764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47765 }
47766 arg2 = static_cast< size_t >(val2);
47767 {
47768 PyThreadState* __tstate = wxPyBeginAllowThreads();
47769 (arg1)->RemoveGrowableCol(arg2);
47770 wxPyEndAllowThreads(__tstate);
47771 if (PyErr_Occurred()) SWIG_fail;
47772 }
47773 resultobj = SWIG_Py_Void();
47774 return resultobj;
47775 fail:
47776 return NULL;
47777 }
47778
47779
47780 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47781 PyObject *resultobj = 0;
47782 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47783 int arg2 ;
47784 void *argp1 = 0 ;
47785 int res1 = 0 ;
47786 int val2 ;
47787 int ecode2 = 0 ;
47788 PyObject * obj0 = 0 ;
47789 PyObject * obj1 = 0 ;
47790 char * kwnames[] = {
47791 (char *) "self",(char *) "direction", NULL
47792 };
47793
47794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
47795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47796 if (!SWIG_IsOK(res1)) {
47797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47798 }
47799 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47800 ecode2 = SWIG_AsVal_int(obj1, &val2);
47801 if (!SWIG_IsOK(ecode2)) {
47802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
47803 }
47804 arg2 = static_cast< int >(val2);
47805 {
47806 PyThreadState* __tstate = wxPyBeginAllowThreads();
47807 (arg1)->SetFlexibleDirection(arg2);
47808 wxPyEndAllowThreads(__tstate);
47809 if (PyErr_Occurred()) SWIG_fail;
47810 }
47811 resultobj = SWIG_Py_Void();
47812 return resultobj;
47813 fail:
47814 return NULL;
47815 }
47816
47817
47818 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47819 PyObject *resultobj = 0;
47820 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47821 int result;
47822 void *argp1 = 0 ;
47823 int res1 = 0 ;
47824 PyObject *swig_obj[1] ;
47825
47826 if (!args) SWIG_fail;
47827 swig_obj[0] = args;
47828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47829 if (!SWIG_IsOK(res1)) {
47830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47831 }
47832 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47833 {
47834 PyThreadState* __tstate = wxPyBeginAllowThreads();
47835 result = (int)(arg1)->GetFlexibleDirection();
47836 wxPyEndAllowThreads(__tstate);
47837 if (PyErr_Occurred()) SWIG_fail;
47838 }
47839 resultobj = SWIG_From_int(static_cast< int >(result));
47840 return resultobj;
47841 fail:
47842 return NULL;
47843 }
47844
47845
47846 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47847 PyObject *resultobj = 0;
47848 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47849 wxFlexSizerGrowMode arg2 ;
47850 void *argp1 = 0 ;
47851 int res1 = 0 ;
47852 int val2 ;
47853 int ecode2 = 0 ;
47854 PyObject * obj0 = 0 ;
47855 PyObject * obj1 = 0 ;
47856 char * kwnames[] = {
47857 (char *) "self",(char *) "mode", NULL
47858 };
47859
47860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
47861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47862 if (!SWIG_IsOK(res1)) {
47863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47864 }
47865 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47866 ecode2 = SWIG_AsVal_int(obj1, &val2);
47867 if (!SWIG_IsOK(ecode2)) {
47868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
47869 }
47870 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
47871 {
47872 PyThreadState* __tstate = wxPyBeginAllowThreads();
47873 (arg1)->SetNonFlexibleGrowMode(arg2);
47874 wxPyEndAllowThreads(__tstate);
47875 if (PyErr_Occurred()) SWIG_fail;
47876 }
47877 resultobj = SWIG_Py_Void();
47878 return resultobj;
47879 fail:
47880 return NULL;
47881 }
47882
47883
47884 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47885 PyObject *resultobj = 0;
47886 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47887 wxFlexSizerGrowMode result;
47888 void *argp1 = 0 ;
47889 int res1 = 0 ;
47890 PyObject *swig_obj[1] ;
47891
47892 if (!args) SWIG_fail;
47893 swig_obj[0] = args;
47894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47895 if (!SWIG_IsOK(res1)) {
47896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47897 }
47898 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47899 {
47900 PyThreadState* __tstate = wxPyBeginAllowThreads();
47901 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
47902 wxPyEndAllowThreads(__tstate);
47903 if (PyErr_Occurred()) SWIG_fail;
47904 }
47905 resultobj = SWIG_From_int(static_cast< int >(result));
47906 return resultobj;
47907 fail:
47908 return NULL;
47909 }
47910
47911
47912 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47913 PyObject *resultobj = 0;
47914 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47915 wxArrayInt *result = 0 ;
47916 void *argp1 = 0 ;
47917 int res1 = 0 ;
47918 PyObject *swig_obj[1] ;
47919
47920 if (!args) SWIG_fail;
47921 swig_obj[0] = args;
47922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47923 if (!SWIG_IsOK(res1)) {
47924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
47925 }
47926 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47927 {
47928 PyThreadState* __tstate = wxPyBeginAllowThreads();
47929 {
47930 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
47931 result = (wxArrayInt *) &_result_ref;
47932 }
47933 wxPyEndAllowThreads(__tstate);
47934 if (PyErr_Occurred()) SWIG_fail;
47935 }
47936 {
47937 resultobj = PyList_New(0);
47938 size_t idx;
47939 for (idx = 0; idx < result->GetCount(); idx += 1) {
47940 PyObject* val = PyInt_FromLong( result->Item(idx) );
47941 PyList_Append(resultobj, val);
47942 Py_DECREF(val);
47943 }
47944 }
47945 return resultobj;
47946 fail:
47947 return NULL;
47948 }
47949
47950
47951 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47952 PyObject *resultobj = 0;
47953 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47954 wxArrayInt *result = 0 ;
47955 void *argp1 = 0 ;
47956 int res1 = 0 ;
47957 PyObject *swig_obj[1] ;
47958
47959 if (!args) SWIG_fail;
47960 swig_obj[0] = args;
47961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47962 if (!SWIG_IsOK(res1)) {
47963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
47964 }
47965 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47966 {
47967 PyThreadState* __tstate = wxPyBeginAllowThreads();
47968 {
47969 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
47970 result = (wxArrayInt *) &_result_ref;
47971 }
47972 wxPyEndAllowThreads(__tstate);
47973 if (PyErr_Occurred()) SWIG_fail;
47974 }
47975 {
47976 resultobj = PyList_New(0);
47977 size_t idx;
47978 for (idx = 0; idx < result->GetCount(); idx += 1) {
47979 PyObject* val = PyInt_FromLong( result->Item(idx) );
47980 PyList_Append(resultobj, val);
47981 Py_DECREF(val);
47982 }
47983 }
47984 return resultobj;
47985 fail:
47986 return NULL;
47987 }
47988
47989
47990 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47991 PyObject *obj;
47992 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47993 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
47994 return SWIG_Py_Void();
47995 }
47996
47997 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47998 return SWIG_Python_InitShadowInstance(args);
47999 }
48000
48001 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48002 PyObject *resultobj = 0;
48003 wxStdDialogButtonSizer *result = 0 ;
48004
48005 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48006 {
48007 PyThreadState* __tstate = wxPyBeginAllowThreads();
48008 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48009 wxPyEndAllowThreads(__tstate);
48010 if (PyErr_Occurred()) SWIG_fail;
48011 }
48012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48013 return resultobj;
48014 fail:
48015 return NULL;
48016 }
48017
48018
48019 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48020 PyObject *resultobj = 0;
48021 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48022 wxButton *arg2 = (wxButton *) 0 ;
48023 void *argp1 = 0 ;
48024 int res1 = 0 ;
48025 void *argp2 = 0 ;
48026 int res2 = 0 ;
48027 PyObject * obj0 = 0 ;
48028 PyObject * obj1 = 0 ;
48029 char * kwnames[] = {
48030 (char *) "self",(char *) "button", NULL
48031 };
48032
48033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48035 if (!SWIG_IsOK(res1)) {
48036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48037 }
48038 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48039 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48040 if (!SWIG_IsOK(res2)) {
48041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48042 }
48043 arg2 = reinterpret_cast< wxButton * >(argp2);
48044 {
48045 PyThreadState* __tstate = wxPyBeginAllowThreads();
48046 (arg1)->AddButton(arg2);
48047 wxPyEndAllowThreads(__tstate);
48048 if (PyErr_Occurred()) SWIG_fail;
48049 }
48050 resultobj = SWIG_Py_Void();
48051 return resultobj;
48052 fail:
48053 return NULL;
48054 }
48055
48056
48057 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48058 PyObject *resultobj = 0;
48059 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48060 void *argp1 = 0 ;
48061 int res1 = 0 ;
48062 PyObject *swig_obj[1] ;
48063
48064 if (!args) SWIG_fail;
48065 swig_obj[0] = args;
48066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48067 if (!SWIG_IsOK(res1)) {
48068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48069 }
48070 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48071 {
48072 PyThreadState* __tstate = wxPyBeginAllowThreads();
48073 (arg1)->Realize();
48074 wxPyEndAllowThreads(__tstate);
48075 if (PyErr_Occurred()) SWIG_fail;
48076 }
48077 resultobj = SWIG_Py_Void();
48078 return resultobj;
48079 fail:
48080 return NULL;
48081 }
48082
48083
48084 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48085 PyObject *resultobj = 0;
48086 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48087 wxButton *arg2 = (wxButton *) 0 ;
48088 void *argp1 = 0 ;
48089 int res1 = 0 ;
48090 void *argp2 = 0 ;
48091 int res2 = 0 ;
48092 PyObject * obj0 = 0 ;
48093 PyObject * obj1 = 0 ;
48094 char * kwnames[] = {
48095 (char *) "self",(char *) "button", NULL
48096 };
48097
48098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48100 if (!SWIG_IsOK(res1)) {
48101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48102 }
48103 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48104 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48105 if (!SWIG_IsOK(res2)) {
48106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48107 }
48108 arg2 = reinterpret_cast< wxButton * >(argp2);
48109 {
48110 PyThreadState* __tstate = wxPyBeginAllowThreads();
48111 (arg1)->SetAffirmativeButton(arg2);
48112 wxPyEndAllowThreads(__tstate);
48113 if (PyErr_Occurred()) SWIG_fail;
48114 }
48115 resultobj = SWIG_Py_Void();
48116 return resultobj;
48117 fail:
48118 return NULL;
48119 }
48120
48121
48122 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48123 PyObject *resultobj = 0;
48124 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48125 wxButton *arg2 = (wxButton *) 0 ;
48126 void *argp1 = 0 ;
48127 int res1 = 0 ;
48128 void *argp2 = 0 ;
48129 int res2 = 0 ;
48130 PyObject * obj0 = 0 ;
48131 PyObject * obj1 = 0 ;
48132 char * kwnames[] = {
48133 (char *) "self",(char *) "button", NULL
48134 };
48135
48136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48138 if (!SWIG_IsOK(res1)) {
48139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48140 }
48141 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48142 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48143 if (!SWIG_IsOK(res2)) {
48144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48145 }
48146 arg2 = reinterpret_cast< wxButton * >(argp2);
48147 {
48148 PyThreadState* __tstate = wxPyBeginAllowThreads();
48149 (arg1)->SetNegativeButton(arg2);
48150 wxPyEndAllowThreads(__tstate);
48151 if (PyErr_Occurred()) SWIG_fail;
48152 }
48153 resultobj = SWIG_Py_Void();
48154 return resultobj;
48155 fail:
48156 return NULL;
48157 }
48158
48159
48160 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48161 PyObject *resultobj = 0;
48162 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48163 wxButton *arg2 = (wxButton *) 0 ;
48164 void *argp1 = 0 ;
48165 int res1 = 0 ;
48166 void *argp2 = 0 ;
48167 int res2 = 0 ;
48168 PyObject * obj0 = 0 ;
48169 PyObject * obj1 = 0 ;
48170 char * kwnames[] = {
48171 (char *) "self",(char *) "button", NULL
48172 };
48173
48174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48176 if (!SWIG_IsOK(res1)) {
48177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48178 }
48179 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48180 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48181 if (!SWIG_IsOK(res2)) {
48182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48183 }
48184 arg2 = reinterpret_cast< wxButton * >(argp2);
48185 {
48186 PyThreadState* __tstate = wxPyBeginAllowThreads();
48187 (arg1)->SetCancelButton(arg2);
48188 wxPyEndAllowThreads(__tstate);
48189 if (PyErr_Occurred()) SWIG_fail;
48190 }
48191 resultobj = SWIG_Py_Void();
48192 return resultobj;
48193 fail:
48194 return NULL;
48195 }
48196
48197
48198 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48199 PyObject *resultobj = 0;
48200 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48201 wxButton *result = 0 ;
48202 void *argp1 = 0 ;
48203 int res1 = 0 ;
48204 PyObject *swig_obj[1] ;
48205
48206 if (!args) SWIG_fail;
48207 swig_obj[0] = args;
48208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48209 if (!SWIG_IsOK(res1)) {
48210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48211 }
48212 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48213 {
48214 PyThreadState* __tstate = wxPyBeginAllowThreads();
48215 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48216 wxPyEndAllowThreads(__tstate);
48217 if (PyErr_Occurred()) SWIG_fail;
48218 }
48219 {
48220 resultobj = wxPyMake_wxObject(result, (bool)0);
48221 }
48222 return resultobj;
48223 fail:
48224 return NULL;
48225 }
48226
48227
48228 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48229 PyObject *resultobj = 0;
48230 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48231 wxButton *result = 0 ;
48232 void *argp1 = 0 ;
48233 int res1 = 0 ;
48234 PyObject *swig_obj[1] ;
48235
48236 if (!args) SWIG_fail;
48237 swig_obj[0] = args;
48238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48239 if (!SWIG_IsOK(res1)) {
48240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48241 }
48242 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48243 {
48244 PyThreadState* __tstate = wxPyBeginAllowThreads();
48245 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48246 wxPyEndAllowThreads(__tstate);
48247 if (PyErr_Occurred()) SWIG_fail;
48248 }
48249 {
48250 resultobj = wxPyMake_wxObject(result, (bool)0);
48251 }
48252 return resultobj;
48253 fail:
48254 return NULL;
48255 }
48256
48257
48258 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48259 PyObject *resultobj = 0;
48260 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48261 wxButton *result = 0 ;
48262 void *argp1 = 0 ;
48263 int res1 = 0 ;
48264 PyObject *swig_obj[1] ;
48265
48266 if (!args) SWIG_fail;
48267 swig_obj[0] = args;
48268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48269 if (!SWIG_IsOK(res1)) {
48270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48271 }
48272 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48273 {
48274 PyThreadState* __tstate = wxPyBeginAllowThreads();
48275 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48276 wxPyEndAllowThreads(__tstate);
48277 if (PyErr_Occurred()) SWIG_fail;
48278 }
48279 {
48280 resultobj = wxPyMake_wxObject(result, (bool)0);
48281 }
48282 return resultobj;
48283 fail:
48284 return NULL;
48285 }
48286
48287
48288 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48289 PyObject *resultobj = 0;
48290 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48291 wxButton *result = 0 ;
48292 void *argp1 = 0 ;
48293 int res1 = 0 ;
48294 PyObject *swig_obj[1] ;
48295
48296 if (!args) SWIG_fail;
48297 swig_obj[0] = args;
48298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48299 if (!SWIG_IsOK(res1)) {
48300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48301 }
48302 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48303 {
48304 PyThreadState* __tstate = wxPyBeginAllowThreads();
48305 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48306 wxPyEndAllowThreads(__tstate);
48307 if (PyErr_Occurred()) SWIG_fail;
48308 }
48309 {
48310 resultobj = wxPyMake_wxObject(result, (bool)0);
48311 }
48312 return resultobj;
48313 fail:
48314 return NULL;
48315 }
48316
48317
48318 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48319 PyObject *resultobj = 0;
48320 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48321 wxButton *result = 0 ;
48322 void *argp1 = 0 ;
48323 int res1 = 0 ;
48324 PyObject *swig_obj[1] ;
48325
48326 if (!args) SWIG_fail;
48327 swig_obj[0] = args;
48328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48329 if (!SWIG_IsOK(res1)) {
48330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48331 }
48332 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48333 {
48334 PyThreadState* __tstate = wxPyBeginAllowThreads();
48335 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48336 wxPyEndAllowThreads(__tstate);
48337 if (PyErr_Occurred()) SWIG_fail;
48338 }
48339 {
48340 resultobj = wxPyMake_wxObject(result, (bool)0);
48341 }
48342 return resultobj;
48343 fail:
48344 return NULL;
48345 }
48346
48347
48348 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48349 PyObject *obj;
48350 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48351 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48352 return SWIG_Py_Void();
48353 }
48354
48355 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48356 return SWIG_Python_InitShadowInstance(args);
48357 }
48358
48359 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48360 PyObject *resultobj = 0;
48361 int arg1 = (int) 0 ;
48362 int arg2 = (int) 0 ;
48363 wxGBPosition *result = 0 ;
48364 int val1 ;
48365 int ecode1 = 0 ;
48366 int val2 ;
48367 int ecode2 = 0 ;
48368 PyObject * obj0 = 0 ;
48369 PyObject * obj1 = 0 ;
48370 char * kwnames[] = {
48371 (char *) "row",(char *) "col", NULL
48372 };
48373
48374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48375 if (obj0) {
48376 ecode1 = SWIG_AsVal_int(obj0, &val1);
48377 if (!SWIG_IsOK(ecode1)) {
48378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48379 }
48380 arg1 = static_cast< int >(val1);
48381 }
48382 if (obj1) {
48383 ecode2 = SWIG_AsVal_int(obj1, &val2);
48384 if (!SWIG_IsOK(ecode2)) {
48385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48386 }
48387 arg2 = static_cast< int >(val2);
48388 }
48389 {
48390 PyThreadState* __tstate = wxPyBeginAllowThreads();
48391 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48392 wxPyEndAllowThreads(__tstate);
48393 if (PyErr_Occurred()) SWIG_fail;
48394 }
48395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48396 return resultobj;
48397 fail:
48398 return NULL;
48399 }
48400
48401
48402 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48403 PyObject *resultobj = 0;
48404 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48405 void *argp1 = 0 ;
48406 int res1 = 0 ;
48407 PyObject *swig_obj[1] ;
48408
48409 if (!args) SWIG_fail;
48410 swig_obj[0] = args;
48411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48412 if (!SWIG_IsOK(res1)) {
48413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48414 }
48415 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48416 {
48417 PyThreadState* __tstate = wxPyBeginAllowThreads();
48418 delete arg1;
48419
48420 wxPyEndAllowThreads(__tstate);
48421 if (PyErr_Occurred()) SWIG_fail;
48422 }
48423 resultobj = SWIG_Py_Void();
48424 return resultobj;
48425 fail:
48426 return NULL;
48427 }
48428
48429
48430 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48431 PyObject *resultobj = 0;
48432 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48433 int result;
48434 void *argp1 = 0 ;
48435 int res1 = 0 ;
48436 PyObject *swig_obj[1] ;
48437
48438 if (!args) SWIG_fail;
48439 swig_obj[0] = args;
48440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48441 if (!SWIG_IsOK(res1)) {
48442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48443 }
48444 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48445 {
48446 PyThreadState* __tstate = wxPyBeginAllowThreads();
48447 result = (int)((wxGBPosition const *)arg1)->GetRow();
48448 wxPyEndAllowThreads(__tstate);
48449 if (PyErr_Occurred()) SWIG_fail;
48450 }
48451 resultobj = SWIG_From_int(static_cast< int >(result));
48452 return resultobj;
48453 fail:
48454 return NULL;
48455 }
48456
48457
48458 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48459 PyObject *resultobj = 0;
48460 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48461 int result;
48462 void *argp1 = 0 ;
48463 int res1 = 0 ;
48464 PyObject *swig_obj[1] ;
48465
48466 if (!args) SWIG_fail;
48467 swig_obj[0] = args;
48468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48469 if (!SWIG_IsOK(res1)) {
48470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48471 }
48472 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48473 {
48474 PyThreadState* __tstate = wxPyBeginAllowThreads();
48475 result = (int)((wxGBPosition const *)arg1)->GetCol();
48476 wxPyEndAllowThreads(__tstate);
48477 if (PyErr_Occurred()) SWIG_fail;
48478 }
48479 resultobj = SWIG_From_int(static_cast< int >(result));
48480 return resultobj;
48481 fail:
48482 return NULL;
48483 }
48484
48485
48486 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48487 PyObject *resultobj = 0;
48488 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48489 int arg2 ;
48490 void *argp1 = 0 ;
48491 int res1 = 0 ;
48492 int val2 ;
48493 int ecode2 = 0 ;
48494 PyObject * obj0 = 0 ;
48495 PyObject * obj1 = 0 ;
48496 char * kwnames[] = {
48497 (char *) "self",(char *) "row", NULL
48498 };
48499
48500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48502 if (!SWIG_IsOK(res1)) {
48503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48504 }
48505 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48506 ecode2 = SWIG_AsVal_int(obj1, &val2);
48507 if (!SWIG_IsOK(ecode2)) {
48508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48509 }
48510 arg2 = static_cast< int >(val2);
48511 {
48512 PyThreadState* __tstate = wxPyBeginAllowThreads();
48513 (arg1)->SetRow(arg2);
48514 wxPyEndAllowThreads(__tstate);
48515 if (PyErr_Occurred()) SWIG_fail;
48516 }
48517 resultobj = SWIG_Py_Void();
48518 return resultobj;
48519 fail:
48520 return NULL;
48521 }
48522
48523
48524 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48525 PyObject *resultobj = 0;
48526 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48527 int arg2 ;
48528 void *argp1 = 0 ;
48529 int res1 = 0 ;
48530 int val2 ;
48531 int ecode2 = 0 ;
48532 PyObject * obj0 = 0 ;
48533 PyObject * obj1 = 0 ;
48534 char * kwnames[] = {
48535 (char *) "self",(char *) "col", NULL
48536 };
48537
48538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48540 if (!SWIG_IsOK(res1)) {
48541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48542 }
48543 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48544 ecode2 = SWIG_AsVal_int(obj1, &val2);
48545 if (!SWIG_IsOK(ecode2)) {
48546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48547 }
48548 arg2 = static_cast< int >(val2);
48549 {
48550 PyThreadState* __tstate = wxPyBeginAllowThreads();
48551 (arg1)->SetCol(arg2);
48552 wxPyEndAllowThreads(__tstate);
48553 if (PyErr_Occurred()) SWIG_fail;
48554 }
48555 resultobj = SWIG_Py_Void();
48556 return resultobj;
48557 fail:
48558 return NULL;
48559 }
48560
48561
48562 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48563 PyObject *resultobj = 0;
48564 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48565 wxGBPosition *arg2 = 0 ;
48566 bool result;
48567 void *argp1 = 0 ;
48568 int res1 = 0 ;
48569 wxGBPosition temp2 ;
48570 PyObject * obj0 = 0 ;
48571 PyObject * obj1 = 0 ;
48572 char * kwnames[] = {
48573 (char *) "self",(char *) "other", NULL
48574 };
48575
48576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48578 if (!SWIG_IsOK(res1)) {
48579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48580 }
48581 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48582 {
48583 arg2 = &temp2;
48584 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48585 }
48586 {
48587 PyThreadState* __tstate = wxPyBeginAllowThreads();
48588 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
48589 wxPyEndAllowThreads(__tstate);
48590 if (PyErr_Occurred()) SWIG_fail;
48591 }
48592 {
48593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48594 }
48595 return resultobj;
48596 fail:
48597 return NULL;
48598 }
48599
48600
48601 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48602 PyObject *resultobj = 0;
48603 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48604 wxGBPosition *arg2 = 0 ;
48605 bool result;
48606 void *argp1 = 0 ;
48607 int res1 = 0 ;
48608 wxGBPosition temp2 ;
48609 PyObject * obj0 = 0 ;
48610 PyObject * obj1 = 0 ;
48611 char * kwnames[] = {
48612 (char *) "self",(char *) "other", NULL
48613 };
48614
48615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48617 if (!SWIG_IsOK(res1)) {
48618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48619 }
48620 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48621 {
48622 arg2 = &temp2;
48623 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48624 }
48625 {
48626 PyThreadState* __tstate = wxPyBeginAllowThreads();
48627 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
48628 wxPyEndAllowThreads(__tstate);
48629 if (PyErr_Occurred()) SWIG_fail;
48630 }
48631 {
48632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48633 }
48634 return resultobj;
48635 fail:
48636 return NULL;
48637 }
48638
48639
48640 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48641 PyObject *resultobj = 0;
48642 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48643 int arg2 = (int) 0 ;
48644 int arg3 = (int) 0 ;
48645 void *argp1 = 0 ;
48646 int res1 = 0 ;
48647 int val2 ;
48648 int ecode2 = 0 ;
48649 int val3 ;
48650 int ecode3 = 0 ;
48651 PyObject * obj0 = 0 ;
48652 PyObject * obj1 = 0 ;
48653 PyObject * obj2 = 0 ;
48654 char * kwnames[] = {
48655 (char *) "self",(char *) "row",(char *) "col", NULL
48656 };
48657
48658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48660 if (!SWIG_IsOK(res1)) {
48661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48662 }
48663 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48664 if (obj1) {
48665 ecode2 = SWIG_AsVal_int(obj1, &val2);
48666 if (!SWIG_IsOK(ecode2)) {
48667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48668 }
48669 arg2 = static_cast< int >(val2);
48670 }
48671 if (obj2) {
48672 ecode3 = SWIG_AsVal_int(obj2, &val3);
48673 if (!SWIG_IsOK(ecode3)) {
48674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48675 }
48676 arg3 = static_cast< int >(val3);
48677 }
48678 {
48679 PyThreadState* __tstate = wxPyBeginAllowThreads();
48680 wxGBPosition_Set(arg1,arg2,arg3);
48681 wxPyEndAllowThreads(__tstate);
48682 if (PyErr_Occurred()) SWIG_fail;
48683 }
48684 resultobj = SWIG_Py_Void();
48685 return resultobj;
48686 fail:
48687 return NULL;
48688 }
48689
48690
48691 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48692 PyObject *resultobj = 0;
48693 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48694 PyObject *result = 0 ;
48695 void *argp1 = 0 ;
48696 int res1 = 0 ;
48697 PyObject *swig_obj[1] ;
48698
48699 if (!args) SWIG_fail;
48700 swig_obj[0] = args;
48701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48702 if (!SWIG_IsOK(res1)) {
48703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48704 }
48705 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48706 {
48707 PyThreadState* __tstate = wxPyBeginAllowThreads();
48708 result = (PyObject *)wxGBPosition_Get(arg1);
48709 wxPyEndAllowThreads(__tstate);
48710 if (PyErr_Occurred()) SWIG_fail;
48711 }
48712 resultobj = result;
48713 return resultobj;
48714 fail:
48715 return NULL;
48716 }
48717
48718
48719 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48720 PyObject *obj;
48721 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48722 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48723 return SWIG_Py_Void();
48724 }
48725
48726 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48727 return SWIG_Python_InitShadowInstance(args);
48728 }
48729
48730 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48731 PyObject *resultobj = 0;
48732 int arg1 = (int) 1 ;
48733 int arg2 = (int) 1 ;
48734 wxGBSpan *result = 0 ;
48735 int val1 ;
48736 int ecode1 = 0 ;
48737 int val2 ;
48738 int ecode2 = 0 ;
48739 PyObject * obj0 = 0 ;
48740 PyObject * obj1 = 0 ;
48741 char * kwnames[] = {
48742 (char *) "rowspan",(char *) "colspan", NULL
48743 };
48744
48745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
48746 if (obj0) {
48747 ecode1 = SWIG_AsVal_int(obj0, &val1);
48748 if (!SWIG_IsOK(ecode1)) {
48749 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
48750 }
48751 arg1 = static_cast< int >(val1);
48752 }
48753 if (obj1) {
48754 ecode2 = SWIG_AsVal_int(obj1, &val2);
48755 if (!SWIG_IsOK(ecode2)) {
48756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
48757 }
48758 arg2 = static_cast< int >(val2);
48759 }
48760 {
48761 PyThreadState* __tstate = wxPyBeginAllowThreads();
48762 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
48763 wxPyEndAllowThreads(__tstate);
48764 if (PyErr_Occurred()) SWIG_fail;
48765 }
48766 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
48767 return resultobj;
48768 fail:
48769 return NULL;
48770 }
48771
48772
48773 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48774 PyObject *resultobj = 0;
48775 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48776 void *argp1 = 0 ;
48777 int res1 = 0 ;
48778 PyObject *swig_obj[1] ;
48779
48780 if (!args) SWIG_fail;
48781 swig_obj[0] = args;
48782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
48783 if (!SWIG_IsOK(res1)) {
48784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48785 }
48786 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48787 {
48788 PyThreadState* __tstate = wxPyBeginAllowThreads();
48789 delete arg1;
48790
48791 wxPyEndAllowThreads(__tstate);
48792 if (PyErr_Occurred()) SWIG_fail;
48793 }
48794 resultobj = SWIG_Py_Void();
48795 return resultobj;
48796 fail:
48797 return NULL;
48798 }
48799
48800
48801 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48802 PyObject *resultobj = 0;
48803 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48804 int result;
48805 void *argp1 = 0 ;
48806 int res1 = 0 ;
48807 PyObject *swig_obj[1] ;
48808
48809 if (!args) SWIG_fail;
48810 swig_obj[0] = args;
48811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48812 if (!SWIG_IsOK(res1)) {
48813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48814 }
48815 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48816 {
48817 PyThreadState* __tstate = wxPyBeginAllowThreads();
48818 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
48819 wxPyEndAllowThreads(__tstate);
48820 if (PyErr_Occurred()) SWIG_fail;
48821 }
48822 resultobj = SWIG_From_int(static_cast< int >(result));
48823 return resultobj;
48824 fail:
48825 return NULL;
48826 }
48827
48828
48829 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48830 PyObject *resultobj = 0;
48831 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48832 int result;
48833 void *argp1 = 0 ;
48834 int res1 = 0 ;
48835 PyObject *swig_obj[1] ;
48836
48837 if (!args) SWIG_fail;
48838 swig_obj[0] = args;
48839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48840 if (!SWIG_IsOK(res1)) {
48841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48842 }
48843 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48844 {
48845 PyThreadState* __tstate = wxPyBeginAllowThreads();
48846 result = (int)((wxGBSpan const *)arg1)->GetColspan();
48847 wxPyEndAllowThreads(__tstate);
48848 if (PyErr_Occurred()) SWIG_fail;
48849 }
48850 resultobj = SWIG_From_int(static_cast< int >(result));
48851 return resultobj;
48852 fail:
48853 return NULL;
48854 }
48855
48856
48857 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48858 PyObject *resultobj = 0;
48859 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48860 int arg2 ;
48861 void *argp1 = 0 ;
48862 int res1 = 0 ;
48863 int val2 ;
48864 int ecode2 = 0 ;
48865 PyObject * obj0 = 0 ;
48866 PyObject * obj1 = 0 ;
48867 char * kwnames[] = {
48868 (char *) "self",(char *) "rowspan", NULL
48869 };
48870
48871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
48872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48873 if (!SWIG_IsOK(res1)) {
48874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48875 }
48876 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48877 ecode2 = SWIG_AsVal_int(obj1, &val2);
48878 if (!SWIG_IsOK(ecode2)) {
48879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
48880 }
48881 arg2 = static_cast< int >(val2);
48882 {
48883 PyThreadState* __tstate = wxPyBeginAllowThreads();
48884 (arg1)->SetRowspan(arg2);
48885 wxPyEndAllowThreads(__tstate);
48886 if (PyErr_Occurred()) SWIG_fail;
48887 }
48888 resultobj = SWIG_Py_Void();
48889 return resultobj;
48890 fail:
48891 return NULL;
48892 }
48893
48894
48895 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48896 PyObject *resultobj = 0;
48897 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48898 int arg2 ;
48899 void *argp1 = 0 ;
48900 int res1 = 0 ;
48901 int val2 ;
48902 int ecode2 = 0 ;
48903 PyObject * obj0 = 0 ;
48904 PyObject * obj1 = 0 ;
48905 char * kwnames[] = {
48906 (char *) "self",(char *) "colspan", NULL
48907 };
48908
48909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
48910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48911 if (!SWIG_IsOK(res1)) {
48912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48913 }
48914 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48915 ecode2 = SWIG_AsVal_int(obj1, &val2);
48916 if (!SWIG_IsOK(ecode2)) {
48917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
48918 }
48919 arg2 = static_cast< int >(val2);
48920 {
48921 PyThreadState* __tstate = wxPyBeginAllowThreads();
48922 (arg1)->SetColspan(arg2);
48923 wxPyEndAllowThreads(__tstate);
48924 if (PyErr_Occurred()) SWIG_fail;
48925 }
48926 resultobj = SWIG_Py_Void();
48927 return resultobj;
48928 fail:
48929 return NULL;
48930 }
48931
48932
48933 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48934 PyObject *resultobj = 0;
48935 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48936 wxGBSpan *arg2 = 0 ;
48937 bool result;
48938 void *argp1 = 0 ;
48939 int res1 = 0 ;
48940 wxGBSpan temp2 ;
48941 PyObject * obj0 = 0 ;
48942 PyObject * obj1 = 0 ;
48943 char * kwnames[] = {
48944 (char *) "self",(char *) "other", NULL
48945 };
48946
48947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48949 if (!SWIG_IsOK(res1)) {
48950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48951 }
48952 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48953 {
48954 arg2 = &temp2;
48955 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
48956 }
48957 {
48958 PyThreadState* __tstate = wxPyBeginAllowThreads();
48959 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
48960 wxPyEndAllowThreads(__tstate);
48961 if (PyErr_Occurred()) SWIG_fail;
48962 }
48963 {
48964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48965 }
48966 return resultobj;
48967 fail:
48968 return NULL;
48969 }
48970
48971
48972 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48973 PyObject *resultobj = 0;
48974 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48975 wxGBSpan *arg2 = 0 ;
48976 bool result;
48977 void *argp1 = 0 ;
48978 int res1 = 0 ;
48979 wxGBSpan temp2 ;
48980 PyObject * obj0 = 0 ;
48981 PyObject * obj1 = 0 ;
48982 char * kwnames[] = {
48983 (char *) "self",(char *) "other", NULL
48984 };
48985
48986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48988 if (!SWIG_IsOK(res1)) {
48989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48990 }
48991 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48992 {
48993 arg2 = &temp2;
48994 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
48995 }
48996 {
48997 PyThreadState* __tstate = wxPyBeginAllowThreads();
48998 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
48999 wxPyEndAllowThreads(__tstate);
49000 if (PyErr_Occurred()) SWIG_fail;
49001 }
49002 {
49003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49004 }
49005 return resultobj;
49006 fail:
49007 return NULL;
49008 }
49009
49010
49011 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49012 PyObject *resultobj = 0;
49013 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49014 int arg2 = (int) 1 ;
49015 int arg3 = (int) 1 ;
49016 void *argp1 = 0 ;
49017 int res1 = 0 ;
49018 int val2 ;
49019 int ecode2 = 0 ;
49020 int val3 ;
49021 int ecode3 = 0 ;
49022 PyObject * obj0 = 0 ;
49023 PyObject * obj1 = 0 ;
49024 PyObject * obj2 = 0 ;
49025 char * kwnames[] = {
49026 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49027 };
49028
49029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49031 if (!SWIG_IsOK(res1)) {
49032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49033 }
49034 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49035 if (obj1) {
49036 ecode2 = SWIG_AsVal_int(obj1, &val2);
49037 if (!SWIG_IsOK(ecode2)) {
49038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49039 }
49040 arg2 = static_cast< int >(val2);
49041 }
49042 if (obj2) {
49043 ecode3 = SWIG_AsVal_int(obj2, &val3);
49044 if (!SWIG_IsOK(ecode3)) {
49045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49046 }
49047 arg3 = static_cast< int >(val3);
49048 }
49049 {
49050 PyThreadState* __tstate = wxPyBeginAllowThreads();
49051 wxGBSpan_Set(arg1,arg2,arg3);
49052 wxPyEndAllowThreads(__tstate);
49053 if (PyErr_Occurred()) SWIG_fail;
49054 }
49055 resultobj = SWIG_Py_Void();
49056 return resultobj;
49057 fail:
49058 return NULL;
49059 }
49060
49061
49062 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49063 PyObject *resultobj = 0;
49064 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49065 PyObject *result = 0 ;
49066 void *argp1 = 0 ;
49067 int res1 = 0 ;
49068 PyObject *swig_obj[1] ;
49069
49070 if (!args) SWIG_fail;
49071 swig_obj[0] = args;
49072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49073 if (!SWIG_IsOK(res1)) {
49074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49075 }
49076 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49077 {
49078 PyThreadState* __tstate = wxPyBeginAllowThreads();
49079 result = (PyObject *)wxGBSpan_Get(arg1);
49080 wxPyEndAllowThreads(__tstate);
49081 if (PyErr_Occurred()) SWIG_fail;
49082 }
49083 resultobj = result;
49084 return resultobj;
49085 fail:
49086 return NULL;
49087 }
49088
49089
49090 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49091 PyObject *obj;
49092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49093 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49094 return SWIG_Py_Void();
49095 }
49096
49097 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49098 return SWIG_Python_InitShadowInstance(args);
49099 }
49100
49101 SWIGINTERN int DefaultSpan_set(PyObject *) {
49102 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49103 return 1;
49104 }
49105
49106
49107 SWIGINTERN PyObject *DefaultSpan_get(void) {
49108 PyObject *pyobj = 0;
49109
49110 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49111 return pyobj;
49112 }
49113
49114
49115 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49116 PyObject *resultobj = 0;
49117 wxGBSizerItem *result = 0 ;
49118
49119 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49120 {
49121 PyThreadState* __tstate = wxPyBeginAllowThreads();
49122 result = (wxGBSizerItem *)new wxGBSizerItem();
49123 wxPyEndAllowThreads(__tstate);
49124 if (PyErr_Occurred()) SWIG_fail;
49125 }
49126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49127 return resultobj;
49128 fail:
49129 return NULL;
49130 }
49131
49132
49133 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49134 PyObject *resultobj = 0;
49135 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49136 void *argp1 = 0 ;
49137 int res1 = 0 ;
49138 PyObject *swig_obj[1] ;
49139
49140 if (!args) SWIG_fail;
49141 swig_obj[0] = args;
49142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49143 if (!SWIG_IsOK(res1)) {
49144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49145 }
49146 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49147 {
49148 PyThreadState* __tstate = wxPyBeginAllowThreads();
49149 delete arg1;
49150
49151 wxPyEndAllowThreads(__tstate);
49152 if (PyErr_Occurred()) SWIG_fail;
49153 }
49154 resultobj = SWIG_Py_Void();
49155 return resultobj;
49156 fail:
49157 return NULL;
49158 }
49159
49160
49161 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49162 PyObject *resultobj = 0;
49163 wxWindow *arg1 = (wxWindow *) 0 ;
49164 wxGBPosition *arg2 = 0 ;
49165 wxGBSpan *arg3 = 0 ;
49166 int arg4 ;
49167 int arg5 ;
49168 PyObject *arg6 = (PyObject *) NULL ;
49169 wxGBSizerItem *result = 0 ;
49170 void *argp1 = 0 ;
49171 int res1 = 0 ;
49172 wxGBPosition temp2 ;
49173 wxGBSpan temp3 ;
49174 int val4 ;
49175 int ecode4 = 0 ;
49176 int val5 ;
49177 int ecode5 = 0 ;
49178 PyObject * obj0 = 0 ;
49179 PyObject * obj1 = 0 ;
49180 PyObject * obj2 = 0 ;
49181 PyObject * obj3 = 0 ;
49182 PyObject * obj4 = 0 ;
49183 PyObject * obj5 = 0 ;
49184 char * kwnames[] = {
49185 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49186 };
49187
49188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49190 if (!SWIG_IsOK(res1)) {
49191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49192 }
49193 arg1 = reinterpret_cast< wxWindow * >(argp1);
49194 {
49195 arg2 = &temp2;
49196 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49197 }
49198 {
49199 arg3 = &temp3;
49200 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49201 }
49202 ecode4 = SWIG_AsVal_int(obj3, &val4);
49203 if (!SWIG_IsOK(ecode4)) {
49204 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49205 }
49206 arg4 = static_cast< int >(val4);
49207 ecode5 = SWIG_AsVal_int(obj4, &val5);
49208 if (!SWIG_IsOK(ecode5)) {
49209 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49210 }
49211 arg5 = static_cast< int >(val5);
49212 if (obj5) {
49213 arg6 = obj5;
49214 }
49215 {
49216 PyThreadState* __tstate = wxPyBeginAllowThreads();
49217 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49218 wxPyEndAllowThreads(__tstate);
49219 if (PyErr_Occurred()) SWIG_fail;
49220 }
49221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49222 return resultobj;
49223 fail:
49224 return NULL;
49225 }
49226
49227
49228 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49229 PyObject *resultobj = 0;
49230 wxSizer *arg1 = (wxSizer *) 0 ;
49231 wxGBPosition *arg2 = 0 ;
49232 wxGBSpan *arg3 = 0 ;
49233 int arg4 ;
49234 int arg5 ;
49235 PyObject *arg6 = (PyObject *) NULL ;
49236 wxGBSizerItem *result = 0 ;
49237 int res1 = 0 ;
49238 wxGBPosition temp2 ;
49239 wxGBSpan temp3 ;
49240 int val4 ;
49241 int ecode4 = 0 ;
49242 int val5 ;
49243 int ecode5 = 0 ;
49244 PyObject * obj0 = 0 ;
49245 PyObject * obj1 = 0 ;
49246 PyObject * obj2 = 0 ;
49247 PyObject * obj3 = 0 ;
49248 PyObject * obj4 = 0 ;
49249 PyObject * obj5 = 0 ;
49250 char * kwnames[] = {
49251 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49252 };
49253
49254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49255 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49256 if (!SWIG_IsOK(res1)) {
49257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49258 }
49259 {
49260 arg2 = &temp2;
49261 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49262 }
49263 {
49264 arg3 = &temp3;
49265 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49266 }
49267 ecode4 = SWIG_AsVal_int(obj3, &val4);
49268 if (!SWIG_IsOK(ecode4)) {
49269 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49270 }
49271 arg4 = static_cast< int >(val4);
49272 ecode5 = SWIG_AsVal_int(obj4, &val5);
49273 if (!SWIG_IsOK(ecode5)) {
49274 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49275 }
49276 arg5 = static_cast< int >(val5);
49277 if (obj5) {
49278 arg6 = obj5;
49279 }
49280 {
49281 PyThreadState* __tstate = wxPyBeginAllowThreads();
49282 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49283 wxPyEndAllowThreads(__tstate);
49284 if (PyErr_Occurred()) SWIG_fail;
49285 }
49286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49287 return resultobj;
49288 fail:
49289 return NULL;
49290 }
49291
49292
49293 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49294 PyObject *resultobj = 0;
49295 int arg1 ;
49296 int arg2 ;
49297 wxGBPosition *arg3 = 0 ;
49298 wxGBSpan *arg4 = 0 ;
49299 int arg5 ;
49300 int arg6 ;
49301 PyObject *arg7 = (PyObject *) NULL ;
49302 wxGBSizerItem *result = 0 ;
49303 int val1 ;
49304 int ecode1 = 0 ;
49305 int val2 ;
49306 int ecode2 = 0 ;
49307 wxGBPosition temp3 ;
49308 wxGBSpan temp4 ;
49309 int val5 ;
49310 int ecode5 = 0 ;
49311 int val6 ;
49312 int ecode6 = 0 ;
49313 PyObject * obj0 = 0 ;
49314 PyObject * obj1 = 0 ;
49315 PyObject * obj2 = 0 ;
49316 PyObject * obj3 = 0 ;
49317 PyObject * obj4 = 0 ;
49318 PyObject * obj5 = 0 ;
49319 PyObject * obj6 = 0 ;
49320 char * kwnames[] = {
49321 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49322 };
49323
49324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49325 ecode1 = SWIG_AsVal_int(obj0, &val1);
49326 if (!SWIG_IsOK(ecode1)) {
49327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49328 }
49329 arg1 = static_cast< int >(val1);
49330 ecode2 = SWIG_AsVal_int(obj1, &val2);
49331 if (!SWIG_IsOK(ecode2)) {
49332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49333 }
49334 arg2 = static_cast< int >(val2);
49335 {
49336 arg3 = &temp3;
49337 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49338 }
49339 {
49340 arg4 = &temp4;
49341 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49342 }
49343 ecode5 = SWIG_AsVal_int(obj4, &val5);
49344 if (!SWIG_IsOK(ecode5)) {
49345 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49346 }
49347 arg5 = static_cast< int >(val5);
49348 ecode6 = SWIG_AsVal_int(obj5, &val6);
49349 if (!SWIG_IsOK(ecode6)) {
49350 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49351 }
49352 arg6 = static_cast< int >(val6);
49353 if (obj6) {
49354 arg7 = obj6;
49355 }
49356 {
49357 PyThreadState* __tstate = wxPyBeginAllowThreads();
49358 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49359 wxPyEndAllowThreads(__tstate);
49360 if (PyErr_Occurred()) SWIG_fail;
49361 }
49362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49363 return resultobj;
49364 fail:
49365 return NULL;
49366 }
49367
49368
49369 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49370 PyObject *resultobj = 0;
49371 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49372 wxGBPosition result;
49373 void *argp1 = 0 ;
49374 int res1 = 0 ;
49375 PyObject *swig_obj[1] ;
49376
49377 if (!args) SWIG_fail;
49378 swig_obj[0] = args;
49379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49380 if (!SWIG_IsOK(res1)) {
49381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49382 }
49383 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49384 {
49385 PyThreadState* __tstate = wxPyBeginAllowThreads();
49386 result = ((wxGBSizerItem const *)arg1)->GetPos();
49387 wxPyEndAllowThreads(__tstate);
49388 if (PyErr_Occurred()) SWIG_fail;
49389 }
49390 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49391 return resultobj;
49392 fail:
49393 return NULL;
49394 }
49395
49396
49397 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49398 PyObject *resultobj = 0;
49399 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49400 wxGBSpan result;
49401 void *argp1 = 0 ;
49402 int res1 = 0 ;
49403 PyObject *swig_obj[1] ;
49404
49405 if (!args) SWIG_fail;
49406 swig_obj[0] = args;
49407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49408 if (!SWIG_IsOK(res1)) {
49409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49410 }
49411 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49412 {
49413 PyThreadState* __tstate = wxPyBeginAllowThreads();
49414 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49415 wxPyEndAllowThreads(__tstate);
49416 if (PyErr_Occurred()) SWIG_fail;
49417 }
49418 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49419 return resultobj;
49420 fail:
49421 return NULL;
49422 }
49423
49424
49425 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49426 PyObject *resultobj = 0;
49427 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49428 wxGBPosition *arg2 = 0 ;
49429 bool result;
49430 void *argp1 = 0 ;
49431 int res1 = 0 ;
49432 wxGBPosition temp2 ;
49433 PyObject * obj0 = 0 ;
49434 PyObject * obj1 = 0 ;
49435 char * kwnames[] = {
49436 (char *) "self",(char *) "pos", NULL
49437 };
49438
49439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49441 if (!SWIG_IsOK(res1)) {
49442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49443 }
49444 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49445 {
49446 arg2 = &temp2;
49447 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49448 }
49449 {
49450 PyThreadState* __tstate = wxPyBeginAllowThreads();
49451 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49452 wxPyEndAllowThreads(__tstate);
49453 if (PyErr_Occurred()) SWIG_fail;
49454 }
49455 {
49456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49457 }
49458 return resultobj;
49459 fail:
49460 return NULL;
49461 }
49462
49463
49464 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49465 PyObject *resultobj = 0;
49466 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49467 wxGBSpan *arg2 = 0 ;
49468 bool result;
49469 void *argp1 = 0 ;
49470 int res1 = 0 ;
49471 wxGBSpan temp2 ;
49472 PyObject * obj0 = 0 ;
49473 PyObject * obj1 = 0 ;
49474 char * kwnames[] = {
49475 (char *) "self",(char *) "span", NULL
49476 };
49477
49478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49480 if (!SWIG_IsOK(res1)) {
49481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49482 }
49483 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49484 {
49485 arg2 = &temp2;
49486 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49487 }
49488 {
49489 PyThreadState* __tstate = wxPyBeginAllowThreads();
49490 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49491 wxPyEndAllowThreads(__tstate);
49492 if (PyErr_Occurred()) SWIG_fail;
49493 }
49494 {
49495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49496 }
49497 return resultobj;
49498 fail:
49499 return NULL;
49500 }
49501
49502
49503 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49504 PyObject *resultobj = 0;
49505 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49506 wxGBSizerItem *arg2 = 0 ;
49507 bool result;
49508 void *argp1 = 0 ;
49509 int res1 = 0 ;
49510 void *argp2 = 0 ;
49511 int res2 = 0 ;
49512 PyObject * obj0 = 0 ;
49513 PyObject * obj1 = 0 ;
49514 char * kwnames[] = {
49515 (char *) "self",(char *) "other", NULL
49516 };
49517
49518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49520 if (!SWIG_IsOK(res1)) {
49521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49522 }
49523 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49524 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49525 if (!SWIG_IsOK(res2)) {
49526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49527 }
49528 if (!argp2) {
49529 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49530 }
49531 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49532 {
49533 PyThreadState* __tstate = wxPyBeginAllowThreads();
49534 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49535 wxPyEndAllowThreads(__tstate);
49536 if (PyErr_Occurred()) SWIG_fail;
49537 }
49538 {
49539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49540 }
49541 return resultobj;
49542 fail:
49543 return NULL;
49544 }
49545
49546
49547 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49548 PyObject *resultobj = 0;
49549 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49550 wxGBPosition *arg2 = 0 ;
49551 wxGBSpan *arg3 = 0 ;
49552 bool result;
49553 void *argp1 = 0 ;
49554 int res1 = 0 ;
49555 wxGBPosition temp2 ;
49556 wxGBSpan temp3 ;
49557 PyObject * obj0 = 0 ;
49558 PyObject * obj1 = 0 ;
49559 PyObject * obj2 = 0 ;
49560 char * kwnames[] = {
49561 (char *) "self",(char *) "pos",(char *) "span", NULL
49562 };
49563
49564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49566 if (!SWIG_IsOK(res1)) {
49567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49568 }
49569 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49570 {
49571 arg2 = &temp2;
49572 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49573 }
49574 {
49575 arg3 = &temp3;
49576 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49577 }
49578 {
49579 PyThreadState* __tstate = wxPyBeginAllowThreads();
49580 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49581 wxPyEndAllowThreads(__tstate);
49582 if (PyErr_Occurred()) SWIG_fail;
49583 }
49584 {
49585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49586 }
49587 return resultobj;
49588 fail:
49589 return NULL;
49590 }
49591
49592
49593 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49594 PyObject *resultobj = 0;
49595 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49596 wxGBPosition result;
49597 void *argp1 = 0 ;
49598 int res1 = 0 ;
49599 PyObject *swig_obj[1] ;
49600
49601 if (!args) SWIG_fail;
49602 swig_obj[0] = args;
49603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49604 if (!SWIG_IsOK(res1)) {
49605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49606 }
49607 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49608 {
49609 PyThreadState* __tstate = wxPyBeginAllowThreads();
49610 result = wxGBSizerItem_GetEndPos(arg1);
49611 wxPyEndAllowThreads(__tstate);
49612 if (PyErr_Occurred()) SWIG_fail;
49613 }
49614 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49615 return resultobj;
49616 fail:
49617 return NULL;
49618 }
49619
49620
49621 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49622 PyObject *resultobj = 0;
49623 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49624 wxGridBagSizer *result = 0 ;
49625 void *argp1 = 0 ;
49626 int res1 = 0 ;
49627 PyObject *swig_obj[1] ;
49628
49629 if (!args) SWIG_fail;
49630 swig_obj[0] = args;
49631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49632 if (!SWIG_IsOK(res1)) {
49633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49634 }
49635 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49636 {
49637 PyThreadState* __tstate = wxPyBeginAllowThreads();
49638 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49639 wxPyEndAllowThreads(__tstate);
49640 if (PyErr_Occurred()) SWIG_fail;
49641 }
49642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49643 return resultobj;
49644 fail:
49645 return NULL;
49646 }
49647
49648
49649 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49650 PyObject *resultobj = 0;
49651 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49652 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49653 void *argp1 = 0 ;
49654 int res1 = 0 ;
49655 void *argp2 = 0 ;
49656 int res2 = 0 ;
49657 PyObject * obj0 = 0 ;
49658 PyObject * obj1 = 0 ;
49659 char * kwnames[] = {
49660 (char *) "self",(char *) "sizer", NULL
49661 };
49662
49663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49665 if (!SWIG_IsOK(res1)) {
49666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49667 }
49668 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49669 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49670 if (!SWIG_IsOK(res2)) {
49671 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49672 }
49673 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49674 {
49675 PyThreadState* __tstate = wxPyBeginAllowThreads();
49676 (arg1)->SetGBSizer(arg2);
49677 wxPyEndAllowThreads(__tstate);
49678 if (PyErr_Occurred()) SWIG_fail;
49679 }
49680 resultobj = SWIG_Py_Void();
49681 return resultobj;
49682 fail:
49683 return NULL;
49684 }
49685
49686
49687 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49688 PyObject *obj;
49689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49690 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49691 return SWIG_Py_Void();
49692 }
49693
49694 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49695 return SWIG_Python_InitShadowInstance(args);
49696 }
49697
49698 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49699 PyObject *resultobj = 0;
49700 int arg1 = (int) 0 ;
49701 int arg2 = (int) 0 ;
49702 wxGridBagSizer *result = 0 ;
49703 int val1 ;
49704 int ecode1 = 0 ;
49705 int val2 ;
49706 int ecode2 = 0 ;
49707 PyObject * obj0 = 0 ;
49708 PyObject * obj1 = 0 ;
49709 char * kwnames[] = {
49710 (char *) "vgap",(char *) "hgap", NULL
49711 };
49712
49713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49714 if (obj0) {
49715 ecode1 = SWIG_AsVal_int(obj0, &val1);
49716 if (!SWIG_IsOK(ecode1)) {
49717 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49718 }
49719 arg1 = static_cast< int >(val1);
49720 }
49721 if (obj1) {
49722 ecode2 = SWIG_AsVal_int(obj1, &val2);
49723 if (!SWIG_IsOK(ecode2)) {
49724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49725 }
49726 arg2 = static_cast< int >(val2);
49727 }
49728 {
49729 PyThreadState* __tstate = wxPyBeginAllowThreads();
49730 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49731 wxPyEndAllowThreads(__tstate);
49732 if (PyErr_Occurred()) SWIG_fail;
49733 }
49734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49735 return resultobj;
49736 fail:
49737 return NULL;
49738 }
49739
49740
49741 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49742 PyObject *resultobj = 0;
49743 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49744 PyObject *arg2 = (PyObject *) 0 ;
49745 wxGBPosition *arg3 = 0 ;
49746 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49747 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49748 int arg5 = (int) 0 ;
49749 int arg6 = (int) 0 ;
49750 PyObject *arg7 = (PyObject *) NULL ;
49751 wxGBSizerItem *result = 0 ;
49752 void *argp1 = 0 ;
49753 int res1 = 0 ;
49754 wxGBPosition temp3 ;
49755 wxGBSpan temp4 ;
49756 int val5 ;
49757 int ecode5 = 0 ;
49758 int val6 ;
49759 int ecode6 = 0 ;
49760 PyObject * obj0 = 0 ;
49761 PyObject * obj1 = 0 ;
49762 PyObject * obj2 = 0 ;
49763 PyObject * obj3 = 0 ;
49764 PyObject * obj4 = 0 ;
49765 PyObject * obj5 = 0 ;
49766 PyObject * obj6 = 0 ;
49767 char * kwnames[] = {
49768 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49769 };
49770
49771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49773 if (!SWIG_IsOK(res1)) {
49774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49775 }
49776 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49777 arg2 = obj1;
49778 {
49779 arg3 = &temp3;
49780 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49781 }
49782 if (obj3) {
49783 {
49784 arg4 = &temp4;
49785 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49786 }
49787 }
49788 if (obj4) {
49789 ecode5 = SWIG_AsVal_int(obj4, &val5);
49790 if (!SWIG_IsOK(ecode5)) {
49791 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
49792 }
49793 arg5 = static_cast< int >(val5);
49794 }
49795 if (obj5) {
49796 ecode6 = SWIG_AsVal_int(obj5, &val6);
49797 if (!SWIG_IsOK(ecode6)) {
49798 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
49799 }
49800 arg6 = static_cast< int >(val6);
49801 }
49802 if (obj6) {
49803 arg7 = obj6;
49804 }
49805 {
49806 PyThreadState* __tstate = wxPyBeginAllowThreads();
49807 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49808 wxPyEndAllowThreads(__tstate);
49809 if (PyErr_Occurred()) SWIG_fail;
49810 }
49811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49812 return resultobj;
49813 fail:
49814 return NULL;
49815 }
49816
49817
49818 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49819 PyObject *resultobj = 0;
49820 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49821 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
49822 wxGBSizerItem *result = 0 ;
49823 void *argp1 = 0 ;
49824 int res1 = 0 ;
49825 int res2 = 0 ;
49826 PyObject * obj0 = 0 ;
49827 PyObject * obj1 = 0 ;
49828 char * kwnames[] = {
49829 (char *) "self",(char *) "item", NULL
49830 };
49831
49832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
49833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49834 if (!SWIG_IsOK(res1)) {
49835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49836 }
49837 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49838 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49839 if (!SWIG_IsOK(res2)) {
49840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
49841 }
49842 {
49843 PyThreadState* __tstate = wxPyBeginAllowThreads();
49844 result = (wxGBSizerItem *)(arg1)->Add(arg2);
49845 wxPyEndAllowThreads(__tstate);
49846 if (PyErr_Occurred()) SWIG_fail;
49847 }
49848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49849 return resultobj;
49850 fail:
49851 return NULL;
49852 }
49853
49854
49855 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49856 PyObject *resultobj = 0;
49857 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49858 int arg2 ;
49859 int arg3 ;
49860 wxSize result;
49861 void *argp1 = 0 ;
49862 int res1 = 0 ;
49863 int val2 ;
49864 int ecode2 = 0 ;
49865 int val3 ;
49866 int ecode3 = 0 ;
49867 PyObject * obj0 = 0 ;
49868 PyObject * obj1 = 0 ;
49869 PyObject * obj2 = 0 ;
49870 char * kwnames[] = {
49871 (char *) "self",(char *) "row",(char *) "col", NULL
49872 };
49873
49874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49876 if (!SWIG_IsOK(res1)) {
49877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
49878 }
49879 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49880 ecode2 = SWIG_AsVal_int(obj1, &val2);
49881 if (!SWIG_IsOK(ecode2)) {
49882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
49883 }
49884 arg2 = static_cast< int >(val2);
49885 ecode3 = SWIG_AsVal_int(obj2, &val3);
49886 if (!SWIG_IsOK(ecode3)) {
49887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
49888 }
49889 arg3 = static_cast< int >(val3);
49890 {
49891 PyThreadState* __tstate = wxPyBeginAllowThreads();
49892 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
49893 wxPyEndAllowThreads(__tstate);
49894 if (PyErr_Occurred()) SWIG_fail;
49895 }
49896 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49897 return resultobj;
49898 fail:
49899 return NULL;
49900 }
49901
49902
49903 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49904 PyObject *resultobj = 0;
49905 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49906 wxSize result;
49907 void *argp1 = 0 ;
49908 int res1 = 0 ;
49909 PyObject *swig_obj[1] ;
49910
49911 if (!args) SWIG_fail;
49912 swig_obj[0] = args;
49913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49914 if (!SWIG_IsOK(res1)) {
49915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
49916 }
49917 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49918 {
49919 PyThreadState* __tstate = wxPyBeginAllowThreads();
49920 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
49921 wxPyEndAllowThreads(__tstate);
49922 if (PyErr_Occurred()) SWIG_fail;
49923 }
49924 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49925 return resultobj;
49926 fail:
49927 return NULL;
49928 }
49929
49930
49931 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49932 PyObject *resultobj = 0;
49933 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49934 wxSize *arg2 = 0 ;
49935 void *argp1 = 0 ;
49936 int res1 = 0 ;
49937 wxSize temp2 ;
49938 PyObject * obj0 = 0 ;
49939 PyObject * obj1 = 0 ;
49940 char * kwnames[] = {
49941 (char *) "self",(char *) "sz", NULL
49942 };
49943
49944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
49945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49946 if (!SWIG_IsOK(res1)) {
49947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49948 }
49949 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49950 {
49951 arg2 = &temp2;
49952 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49953 }
49954 {
49955 PyThreadState* __tstate = wxPyBeginAllowThreads();
49956 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
49957 wxPyEndAllowThreads(__tstate);
49958 if (PyErr_Occurred()) SWIG_fail;
49959 }
49960 resultobj = SWIG_Py_Void();
49961 return resultobj;
49962 fail:
49963 return NULL;
49964 }
49965
49966
49967 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
49968 PyObject *resultobj = 0;
49969 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49970 wxWindow *arg2 = (wxWindow *) 0 ;
49971 wxGBPosition result;
49972 void *argp1 = 0 ;
49973 int res1 = 0 ;
49974 void *argp2 = 0 ;
49975 int res2 = 0 ;
49976
49977 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
49978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49979 if (!SWIG_IsOK(res1)) {
49980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49981 }
49982 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49983 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49984 if (!SWIG_IsOK(res2)) {
49985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
49986 }
49987 arg2 = reinterpret_cast< wxWindow * >(argp2);
49988 {
49989 PyThreadState* __tstate = wxPyBeginAllowThreads();
49990 result = (arg1)->GetItemPosition(arg2);
49991 wxPyEndAllowThreads(__tstate);
49992 if (PyErr_Occurred()) SWIG_fail;
49993 }
49994 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49995 return resultobj;
49996 fail:
49997 return NULL;
49998 }
49999
50000
50001 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50002 PyObject *resultobj = 0;
50003 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50004 wxSizer *arg2 = (wxSizer *) 0 ;
50005 wxGBPosition result;
50006 void *argp1 = 0 ;
50007 int res1 = 0 ;
50008 void *argp2 = 0 ;
50009 int res2 = 0 ;
50010
50011 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50013 if (!SWIG_IsOK(res1)) {
50014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50015 }
50016 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50017 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50018 if (!SWIG_IsOK(res2)) {
50019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50020 }
50021 arg2 = reinterpret_cast< wxSizer * >(argp2);
50022 {
50023 PyThreadState* __tstate = wxPyBeginAllowThreads();
50024 result = (arg1)->GetItemPosition(arg2);
50025 wxPyEndAllowThreads(__tstate);
50026 if (PyErr_Occurred()) SWIG_fail;
50027 }
50028 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50029 return resultobj;
50030 fail:
50031 return NULL;
50032 }
50033
50034
50035 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50036 PyObject *resultobj = 0;
50037 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50038 size_t arg2 ;
50039 wxGBPosition result;
50040 void *argp1 = 0 ;
50041 int res1 = 0 ;
50042 size_t val2 ;
50043 int ecode2 = 0 ;
50044
50045 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50047 if (!SWIG_IsOK(res1)) {
50048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50049 }
50050 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50051 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50052 if (!SWIG_IsOK(ecode2)) {
50053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50054 }
50055 arg2 = static_cast< size_t >(val2);
50056 {
50057 PyThreadState* __tstate = wxPyBeginAllowThreads();
50058 result = (arg1)->GetItemPosition(arg2);
50059 wxPyEndAllowThreads(__tstate);
50060 if (PyErr_Occurred()) SWIG_fail;
50061 }
50062 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50063 return resultobj;
50064 fail:
50065 return NULL;
50066 }
50067
50068
50069 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50070 int argc;
50071 PyObject *argv[3];
50072
50073 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50074 --argc;
50075 if (argc == 2) {
50076 int _v = 0;
50077 {
50078 void *vptr = 0;
50079 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50080 _v = SWIG_CheckState(res);
50081 }
50082 if (!_v) goto check_1;
50083 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50084 }
50085 check_1:
50086
50087 if (argc == 2) {
50088 int _v = 0;
50089 {
50090 void *vptr = 0;
50091 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50092 _v = SWIG_CheckState(res);
50093 }
50094 if (!_v) goto check_2;
50095 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50096 }
50097 check_2:
50098
50099 if (argc == 2) {
50100 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50101 }
50102
50103 fail:
50104 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50105 return NULL;
50106 }
50107
50108
50109 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50110 PyObject *resultobj = 0;
50111 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50112 wxWindow *arg2 = (wxWindow *) 0 ;
50113 wxGBPosition *arg3 = 0 ;
50114 bool result;
50115 void *argp1 = 0 ;
50116 int res1 = 0 ;
50117 void *argp2 = 0 ;
50118 int res2 = 0 ;
50119 wxGBPosition temp3 ;
50120
50121 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50123 if (!SWIG_IsOK(res1)) {
50124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50125 }
50126 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50127 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50128 if (!SWIG_IsOK(res2)) {
50129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50130 }
50131 arg2 = reinterpret_cast< wxWindow * >(argp2);
50132 {
50133 arg3 = &temp3;
50134 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50135 }
50136 {
50137 PyThreadState* __tstate = wxPyBeginAllowThreads();
50138 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50139 wxPyEndAllowThreads(__tstate);
50140 if (PyErr_Occurred()) SWIG_fail;
50141 }
50142 {
50143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50144 }
50145 return resultobj;
50146 fail:
50147 return NULL;
50148 }
50149
50150
50151 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50152 PyObject *resultobj = 0;
50153 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50154 wxSizer *arg2 = (wxSizer *) 0 ;
50155 wxGBPosition *arg3 = 0 ;
50156 bool result;
50157 void *argp1 = 0 ;
50158 int res1 = 0 ;
50159 void *argp2 = 0 ;
50160 int res2 = 0 ;
50161 wxGBPosition temp3 ;
50162
50163 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50165 if (!SWIG_IsOK(res1)) {
50166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50167 }
50168 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50169 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50170 if (!SWIG_IsOK(res2)) {
50171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50172 }
50173 arg2 = reinterpret_cast< wxSizer * >(argp2);
50174 {
50175 arg3 = &temp3;
50176 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50177 }
50178 {
50179 PyThreadState* __tstate = wxPyBeginAllowThreads();
50180 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50181 wxPyEndAllowThreads(__tstate);
50182 if (PyErr_Occurred()) SWIG_fail;
50183 }
50184 {
50185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50186 }
50187 return resultobj;
50188 fail:
50189 return NULL;
50190 }
50191
50192
50193 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50194 PyObject *resultobj = 0;
50195 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50196 size_t arg2 ;
50197 wxGBPosition *arg3 = 0 ;
50198 bool result;
50199 void *argp1 = 0 ;
50200 int res1 = 0 ;
50201 size_t val2 ;
50202 int ecode2 = 0 ;
50203 wxGBPosition temp3 ;
50204
50205 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50207 if (!SWIG_IsOK(res1)) {
50208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50209 }
50210 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50211 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50212 if (!SWIG_IsOK(ecode2)) {
50213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50214 }
50215 arg2 = static_cast< size_t >(val2);
50216 {
50217 arg3 = &temp3;
50218 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50219 }
50220 {
50221 PyThreadState* __tstate = wxPyBeginAllowThreads();
50222 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50223 wxPyEndAllowThreads(__tstate);
50224 if (PyErr_Occurred()) SWIG_fail;
50225 }
50226 {
50227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50228 }
50229 return resultobj;
50230 fail:
50231 return NULL;
50232 }
50233
50234
50235 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50236 int argc;
50237 PyObject *argv[4];
50238
50239 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50240 --argc;
50241 if (argc == 3) {
50242 int _v = 0;
50243 {
50244 void *vptr = 0;
50245 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50246 _v = SWIG_CheckState(res);
50247 }
50248 if (!_v) goto check_1;
50249 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50250 }
50251 check_1:
50252
50253 if (argc == 3) {
50254 int _v = 0;
50255 {
50256 void *vptr = 0;
50257 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50258 _v = SWIG_CheckState(res);
50259 }
50260 if (!_v) goto check_2;
50261 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50262 }
50263 check_2:
50264
50265 if (argc == 3) {
50266 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50267 }
50268
50269 fail:
50270 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50271 return NULL;
50272 }
50273
50274
50275 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50276 PyObject *resultobj = 0;
50277 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50278 wxWindow *arg2 = (wxWindow *) 0 ;
50279 wxGBSpan result;
50280 void *argp1 = 0 ;
50281 int res1 = 0 ;
50282 void *argp2 = 0 ;
50283 int res2 = 0 ;
50284
50285 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50287 if (!SWIG_IsOK(res1)) {
50288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50289 }
50290 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50291 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50292 if (!SWIG_IsOK(res2)) {
50293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50294 }
50295 arg2 = reinterpret_cast< wxWindow * >(argp2);
50296 {
50297 PyThreadState* __tstate = wxPyBeginAllowThreads();
50298 result = (arg1)->GetItemSpan(arg2);
50299 wxPyEndAllowThreads(__tstate);
50300 if (PyErr_Occurred()) SWIG_fail;
50301 }
50302 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50303 return resultobj;
50304 fail:
50305 return NULL;
50306 }
50307
50308
50309 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50310 PyObject *resultobj = 0;
50311 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50312 wxSizer *arg2 = (wxSizer *) 0 ;
50313 wxGBSpan result;
50314 void *argp1 = 0 ;
50315 int res1 = 0 ;
50316 void *argp2 = 0 ;
50317 int res2 = 0 ;
50318
50319 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50321 if (!SWIG_IsOK(res1)) {
50322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50323 }
50324 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50325 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50326 if (!SWIG_IsOK(res2)) {
50327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50328 }
50329 arg2 = reinterpret_cast< wxSizer * >(argp2);
50330 {
50331 PyThreadState* __tstate = wxPyBeginAllowThreads();
50332 result = (arg1)->GetItemSpan(arg2);
50333 wxPyEndAllowThreads(__tstate);
50334 if (PyErr_Occurred()) SWIG_fail;
50335 }
50336 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50337 return resultobj;
50338 fail:
50339 return NULL;
50340 }
50341
50342
50343 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50344 PyObject *resultobj = 0;
50345 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50346 size_t arg2 ;
50347 wxGBSpan result;
50348 void *argp1 = 0 ;
50349 int res1 = 0 ;
50350 size_t val2 ;
50351 int ecode2 = 0 ;
50352
50353 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50355 if (!SWIG_IsOK(res1)) {
50356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50357 }
50358 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50359 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50360 if (!SWIG_IsOK(ecode2)) {
50361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50362 }
50363 arg2 = static_cast< size_t >(val2);
50364 {
50365 PyThreadState* __tstate = wxPyBeginAllowThreads();
50366 result = (arg1)->GetItemSpan(arg2);
50367 wxPyEndAllowThreads(__tstate);
50368 if (PyErr_Occurred()) SWIG_fail;
50369 }
50370 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50371 return resultobj;
50372 fail:
50373 return NULL;
50374 }
50375
50376
50377 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50378 int argc;
50379 PyObject *argv[3];
50380
50381 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50382 --argc;
50383 if (argc == 2) {
50384 int _v = 0;
50385 {
50386 void *vptr = 0;
50387 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50388 _v = SWIG_CheckState(res);
50389 }
50390 if (!_v) goto check_1;
50391 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50392 }
50393 check_1:
50394
50395 if (argc == 2) {
50396 int _v = 0;
50397 {
50398 void *vptr = 0;
50399 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50400 _v = SWIG_CheckState(res);
50401 }
50402 if (!_v) goto check_2;
50403 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50404 }
50405 check_2:
50406
50407 if (argc == 2) {
50408 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50409 }
50410
50411 fail:
50412 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50413 return NULL;
50414 }
50415
50416
50417 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50418 PyObject *resultobj = 0;
50419 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50420 wxWindow *arg2 = (wxWindow *) 0 ;
50421 wxGBSpan *arg3 = 0 ;
50422 bool result;
50423 void *argp1 = 0 ;
50424 int res1 = 0 ;
50425 void *argp2 = 0 ;
50426 int res2 = 0 ;
50427 wxGBSpan temp3 ;
50428
50429 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50431 if (!SWIG_IsOK(res1)) {
50432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50433 }
50434 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50435 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50436 if (!SWIG_IsOK(res2)) {
50437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50438 }
50439 arg2 = reinterpret_cast< wxWindow * >(argp2);
50440 {
50441 arg3 = &temp3;
50442 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50443 }
50444 {
50445 PyThreadState* __tstate = wxPyBeginAllowThreads();
50446 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50447 wxPyEndAllowThreads(__tstate);
50448 if (PyErr_Occurred()) SWIG_fail;
50449 }
50450 {
50451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50452 }
50453 return resultobj;
50454 fail:
50455 return NULL;
50456 }
50457
50458
50459 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50460 PyObject *resultobj = 0;
50461 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50462 wxSizer *arg2 = (wxSizer *) 0 ;
50463 wxGBSpan *arg3 = 0 ;
50464 bool result;
50465 void *argp1 = 0 ;
50466 int res1 = 0 ;
50467 void *argp2 = 0 ;
50468 int res2 = 0 ;
50469 wxGBSpan temp3 ;
50470
50471 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50473 if (!SWIG_IsOK(res1)) {
50474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50475 }
50476 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50477 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50478 if (!SWIG_IsOK(res2)) {
50479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50480 }
50481 arg2 = reinterpret_cast< wxSizer * >(argp2);
50482 {
50483 arg3 = &temp3;
50484 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50485 }
50486 {
50487 PyThreadState* __tstate = wxPyBeginAllowThreads();
50488 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50489 wxPyEndAllowThreads(__tstate);
50490 if (PyErr_Occurred()) SWIG_fail;
50491 }
50492 {
50493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50494 }
50495 return resultobj;
50496 fail:
50497 return NULL;
50498 }
50499
50500
50501 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50502 PyObject *resultobj = 0;
50503 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50504 size_t arg2 ;
50505 wxGBSpan *arg3 = 0 ;
50506 bool result;
50507 void *argp1 = 0 ;
50508 int res1 = 0 ;
50509 size_t val2 ;
50510 int ecode2 = 0 ;
50511 wxGBSpan temp3 ;
50512
50513 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50515 if (!SWIG_IsOK(res1)) {
50516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50517 }
50518 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50519 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50520 if (!SWIG_IsOK(ecode2)) {
50521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50522 }
50523 arg2 = static_cast< size_t >(val2);
50524 {
50525 arg3 = &temp3;
50526 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50527 }
50528 {
50529 PyThreadState* __tstate = wxPyBeginAllowThreads();
50530 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50531 wxPyEndAllowThreads(__tstate);
50532 if (PyErr_Occurred()) SWIG_fail;
50533 }
50534 {
50535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50536 }
50537 return resultobj;
50538 fail:
50539 return NULL;
50540 }
50541
50542
50543 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50544 int argc;
50545 PyObject *argv[4];
50546
50547 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50548 --argc;
50549 if (argc == 3) {
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_SetItemSpan__SWIG_0(self, argc, argv);
50558 }
50559 check_1:
50560
50561 if (argc == 3) {
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_SetItemSpan__SWIG_1(self, argc, argv);
50570 }
50571 check_2:
50572
50573 if (argc == 3) {
50574 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50575 }
50576
50577 fail:
50578 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50579 return NULL;
50580 }
50581
50582
50583 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__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 wxGBSizerItem *result = 0 ;
50588 void *argp1 = 0 ;
50589 int res1 = 0 ;
50590 void *argp2 = 0 ;
50591 int res2 = 0 ;
50592
50593 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50595 if (!SWIG_IsOK(res1)) {
50596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50597 }
50598 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50599 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50600 if (!SWIG_IsOK(res2)) {
50601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50602 }
50603 arg2 = reinterpret_cast< wxWindow * >(argp2);
50604 {
50605 PyThreadState* __tstate = wxPyBeginAllowThreads();
50606 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50607 wxPyEndAllowThreads(__tstate);
50608 if (PyErr_Occurred()) SWIG_fail;
50609 }
50610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50611 return resultobj;
50612 fail:
50613 return NULL;
50614 }
50615
50616
50617 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50618 PyObject *resultobj = 0;
50619 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50620 wxSizer *arg2 = (wxSizer *) 0 ;
50621 wxGBSizerItem *result = 0 ;
50622 void *argp1 = 0 ;
50623 int res1 = 0 ;
50624 void *argp2 = 0 ;
50625 int res2 = 0 ;
50626
50627 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50629 if (!SWIG_IsOK(res1)) {
50630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50631 }
50632 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50633 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50634 if (!SWIG_IsOK(res2)) {
50635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50636 }
50637 arg2 = reinterpret_cast< wxSizer * >(argp2);
50638 {
50639 PyThreadState* __tstate = wxPyBeginAllowThreads();
50640 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50641 wxPyEndAllowThreads(__tstate);
50642 if (PyErr_Occurred()) SWIG_fail;
50643 }
50644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50645 return resultobj;
50646 fail:
50647 return NULL;
50648 }
50649
50650
50651 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50652 int argc;
50653 PyObject *argv[3];
50654
50655 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50656 --argc;
50657 if (argc == 2) {
50658 int _v = 0;
50659 {
50660 void *vptr = 0;
50661 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50662 _v = SWIG_CheckState(res);
50663 }
50664 if (!_v) goto check_1;
50665 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50666 }
50667 check_1:
50668
50669 if (argc == 2) {
50670 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50671 }
50672
50673 fail:
50674 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50675 return NULL;
50676 }
50677
50678
50679 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50680 PyObject *resultobj = 0;
50681 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50682 wxGBPosition *arg2 = 0 ;
50683 wxGBSizerItem *result = 0 ;
50684 void *argp1 = 0 ;
50685 int res1 = 0 ;
50686 wxGBPosition temp2 ;
50687 PyObject * obj0 = 0 ;
50688 PyObject * obj1 = 0 ;
50689 char * kwnames[] = {
50690 (char *) "self",(char *) "pos", NULL
50691 };
50692
50693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50695 if (!SWIG_IsOK(res1)) {
50696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50697 }
50698 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50699 {
50700 arg2 = &temp2;
50701 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50702 }
50703 {
50704 PyThreadState* __tstate = wxPyBeginAllowThreads();
50705 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50706 wxPyEndAllowThreads(__tstate);
50707 if (PyErr_Occurred()) SWIG_fail;
50708 }
50709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50710 return resultobj;
50711 fail:
50712 return NULL;
50713 }
50714
50715
50716 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50717 PyObject *resultobj = 0;
50718 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50719 wxPoint *arg2 = 0 ;
50720 wxGBSizerItem *result = 0 ;
50721 void *argp1 = 0 ;
50722 int res1 = 0 ;
50723 wxPoint temp2 ;
50724 PyObject * obj0 = 0 ;
50725 PyObject * obj1 = 0 ;
50726 char * kwnames[] = {
50727 (char *) "self",(char *) "pt", NULL
50728 };
50729
50730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50732 if (!SWIG_IsOK(res1)) {
50733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50734 }
50735 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50736 {
50737 arg2 = &temp2;
50738 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50739 }
50740 {
50741 PyThreadState* __tstate = wxPyBeginAllowThreads();
50742 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50743 wxPyEndAllowThreads(__tstate);
50744 if (PyErr_Occurred()) SWIG_fail;
50745 }
50746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50747 return resultobj;
50748 fail:
50749 return NULL;
50750 }
50751
50752
50753 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50754 PyObject *resultobj = 0;
50755 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50756 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50757 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
50758 bool result;
50759 void *argp1 = 0 ;
50760 int res1 = 0 ;
50761 void *argp2 = 0 ;
50762 int res2 = 0 ;
50763 void *argp3 = 0 ;
50764 int res3 = 0 ;
50765 PyObject * obj0 = 0 ;
50766 PyObject * obj1 = 0 ;
50767 PyObject * obj2 = 0 ;
50768 char * kwnames[] = {
50769 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
50770 };
50771
50772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50774 if (!SWIG_IsOK(res1)) {
50775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50776 }
50777 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50778 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50779 if (!SWIG_IsOK(res2)) {
50780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50781 }
50782 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50783 if (obj2) {
50784 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50785 if (!SWIG_IsOK(res3)) {
50786 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
50787 }
50788 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
50789 }
50790 {
50791 PyThreadState* __tstate = wxPyBeginAllowThreads();
50792 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
50793 wxPyEndAllowThreads(__tstate);
50794 if (PyErr_Occurred()) SWIG_fail;
50795 }
50796 {
50797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50798 }
50799 return resultobj;
50800 fail:
50801 return NULL;
50802 }
50803
50804
50805 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50806 PyObject *resultobj = 0;
50807 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50808 wxGBPosition *arg2 = 0 ;
50809 wxGBSpan *arg3 = 0 ;
50810 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
50811 bool result;
50812 void *argp1 = 0 ;
50813 int res1 = 0 ;
50814 wxGBPosition temp2 ;
50815 wxGBSpan temp3 ;
50816 void *argp4 = 0 ;
50817 int res4 = 0 ;
50818 PyObject * obj0 = 0 ;
50819 PyObject * obj1 = 0 ;
50820 PyObject * obj2 = 0 ;
50821 PyObject * obj3 = 0 ;
50822 char * kwnames[] = {
50823 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
50824 };
50825
50826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50828 if (!SWIG_IsOK(res1)) {
50829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50830 }
50831 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50832 {
50833 arg2 = &temp2;
50834 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50835 }
50836 {
50837 arg3 = &temp3;
50838 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50839 }
50840 if (obj3) {
50841 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50842 if (!SWIG_IsOK(res4)) {
50843 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
50844 }
50845 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
50846 }
50847 {
50848 PyThreadState* __tstate = wxPyBeginAllowThreads();
50849 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
50850 wxPyEndAllowThreads(__tstate);
50851 if (PyErr_Occurred()) SWIG_fail;
50852 }
50853 {
50854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50855 }
50856 return resultobj;
50857 fail:
50858 return NULL;
50859 }
50860
50861
50862 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50863 PyObject *obj;
50864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50865 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
50866 return SWIG_Py_Void();
50867 }
50868
50869 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50870 return SWIG_Python_InitShadowInstance(args);
50871 }
50872
50873 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50874 PyObject *resultobj = 0;
50875 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
50876 wxRelationship arg2 ;
50877 wxWindow *arg3 = (wxWindow *) 0 ;
50878 wxEdge arg4 ;
50879 int arg5 = (int) 0 ;
50880 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
50881 void *argp1 = 0 ;
50882 int res1 = 0 ;
50883 int val2 ;
50884 int ecode2 = 0 ;
50885 void *argp3 = 0 ;
50886 int res3 = 0 ;
50887 int val4 ;
50888 int ecode4 = 0 ;
50889 int val5 ;
50890 int ecode5 = 0 ;
50891 int val6 ;
50892 int ecode6 = 0 ;
50893 PyObject * obj0 = 0 ;
50894 PyObject * obj1 = 0 ;
50895 PyObject * obj2 = 0 ;
50896 PyObject * obj3 = 0 ;
50897 PyObject * obj4 = 0 ;
50898 PyObject * obj5 = 0 ;
50899 char * kwnames[] = {
50900 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
50901 };
50902
50903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
50905 if (!SWIG_IsOK(res1)) {
50906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
50907 }
50908 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
50909 ecode2 = SWIG_AsVal_int(obj1, &val2);
50910 if (!SWIG_IsOK(ecode2)) {
50911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
50912 }
50913 arg2 = static_cast< wxRelationship >(val2);
50914 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50915 if (!SWIG_IsOK(res3)) {
50916 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
50917 }
50918 arg3 = reinterpret_cast< wxWindow * >(argp3);
50919 ecode4 = SWIG_AsVal_int(obj3, &val4);
50920 if (!SWIG_IsOK(ecode4)) {
50921 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
50922 }
50923 arg4 = static_cast< wxEdge >(val4);
50924 if (obj4) {
50925 ecode5 = SWIG_AsVal_int(obj4, &val5);
50926 if (!SWIG_IsOK(ecode5)) {
50927 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
50928 }
50929 arg5 = static_cast< int >(val5);
50930 }
50931 if (obj5) {
50932 ecode6 = SWIG_AsVal_int(obj5, &val6);
50933 if (!SWIG_IsOK(ecode6)) {
50934 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
50935 }
50936 arg6 = static_cast< int >(val6);
50937 }
50938 {
50939 PyThreadState* __tstate = wxPyBeginAllowThreads();
50940 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
50941 wxPyEndAllowThreads(__tstate);
50942 if (PyErr_Occurred()) SWIG_fail;
50943 }
50944 resultobj = SWIG_Py_Void();
50945 return resultobj;
50946 fail:
50947 return NULL;
50948 }
50949
50950
50951 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50952 PyObject *resultobj = 0;
50953 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
50954 wxWindow *arg2 = (wxWindow *) 0 ;
50955 int arg3 = (int) 0 ;
50956 void *argp1 = 0 ;
50957 int res1 = 0 ;
50958 void *argp2 = 0 ;
50959 int res2 = 0 ;
50960 int val3 ;
50961 int ecode3 = 0 ;
50962 PyObject * obj0 = 0 ;
50963 PyObject * obj1 = 0 ;
50964 PyObject * obj2 = 0 ;
50965 char * kwnames[] = {
50966 (char *) "self",(char *) "sibling",(char *) "marg", NULL
50967 };
50968
50969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
50971 if (!SWIG_IsOK(res1)) {
50972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
50973 }
50974 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
50975 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50976 if (!SWIG_IsOK(res2)) {
50977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
50978 }
50979 arg2 = reinterpret_cast< wxWindow * >(argp2);
50980 if (obj2) {
50981 ecode3 = SWIG_AsVal_int(obj2, &val3);
50982 if (!SWIG_IsOK(ecode3)) {
50983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
50984 }
50985 arg3 = static_cast< int >(val3);
50986 }
50987 {
50988 PyThreadState* __tstate = wxPyBeginAllowThreads();
50989 (arg1)->LeftOf(arg2,arg3);
50990 wxPyEndAllowThreads(__tstate);
50991 if (PyErr_Occurred()) SWIG_fail;
50992 }
50993 resultobj = SWIG_Py_Void();
50994 return resultobj;
50995 fail:
50996 return NULL;
50997 }
50998
50999
51000 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51001 PyObject *resultobj = 0;
51002 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51003 wxWindow *arg2 = (wxWindow *) 0 ;
51004 int arg3 = (int) 0 ;
51005 void *argp1 = 0 ;
51006 int res1 = 0 ;
51007 void *argp2 = 0 ;
51008 int res2 = 0 ;
51009 int val3 ;
51010 int ecode3 = 0 ;
51011 PyObject * obj0 = 0 ;
51012 PyObject * obj1 = 0 ;
51013 PyObject * obj2 = 0 ;
51014 char * kwnames[] = {
51015 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51016 };
51017
51018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51020 if (!SWIG_IsOK(res1)) {
51021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51022 }
51023 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51024 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51025 if (!SWIG_IsOK(res2)) {
51026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51027 }
51028 arg2 = reinterpret_cast< wxWindow * >(argp2);
51029 if (obj2) {
51030 ecode3 = SWIG_AsVal_int(obj2, &val3);
51031 if (!SWIG_IsOK(ecode3)) {
51032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51033 }
51034 arg3 = static_cast< int >(val3);
51035 }
51036 {
51037 PyThreadState* __tstate = wxPyBeginAllowThreads();
51038 (arg1)->RightOf(arg2,arg3);
51039 wxPyEndAllowThreads(__tstate);
51040 if (PyErr_Occurred()) SWIG_fail;
51041 }
51042 resultobj = SWIG_Py_Void();
51043 return resultobj;
51044 fail:
51045 return NULL;
51046 }
51047
51048
51049 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51050 PyObject *resultobj = 0;
51051 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51052 wxWindow *arg2 = (wxWindow *) 0 ;
51053 int arg3 = (int) 0 ;
51054 void *argp1 = 0 ;
51055 int res1 = 0 ;
51056 void *argp2 = 0 ;
51057 int res2 = 0 ;
51058 int val3 ;
51059 int ecode3 = 0 ;
51060 PyObject * obj0 = 0 ;
51061 PyObject * obj1 = 0 ;
51062 PyObject * obj2 = 0 ;
51063 char * kwnames[] = {
51064 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51065 };
51066
51067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51069 if (!SWIG_IsOK(res1)) {
51070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51071 }
51072 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51073 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51074 if (!SWIG_IsOK(res2)) {
51075 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51076 }
51077 arg2 = reinterpret_cast< wxWindow * >(argp2);
51078 if (obj2) {
51079 ecode3 = SWIG_AsVal_int(obj2, &val3);
51080 if (!SWIG_IsOK(ecode3)) {
51081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51082 }
51083 arg3 = static_cast< int >(val3);
51084 }
51085 {
51086 PyThreadState* __tstate = wxPyBeginAllowThreads();
51087 (arg1)->Above(arg2,arg3);
51088 wxPyEndAllowThreads(__tstate);
51089 if (PyErr_Occurred()) SWIG_fail;
51090 }
51091 resultobj = SWIG_Py_Void();
51092 return resultobj;
51093 fail:
51094 return NULL;
51095 }
51096
51097
51098 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51099 PyObject *resultobj = 0;
51100 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51101 wxWindow *arg2 = (wxWindow *) 0 ;
51102 int arg3 = (int) 0 ;
51103 void *argp1 = 0 ;
51104 int res1 = 0 ;
51105 void *argp2 = 0 ;
51106 int res2 = 0 ;
51107 int val3 ;
51108 int ecode3 = 0 ;
51109 PyObject * obj0 = 0 ;
51110 PyObject * obj1 = 0 ;
51111 PyObject * obj2 = 0 ;
51112 char * kwnames[] = {
51113 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51114 };
51115
51116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51118 if (!SWIG_IsOK(res1)) {
51119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51120 }
51121 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51122 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51123 if (!SWIG_IsOK(res2)) {
51124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51125 }
51126 arg2 = reinterpret_cast< wxWindow * >(argp2);
51127 if (obj2) {
51128 ecode3 = SWIG_AsVal_int(obj2, &val3);
51129 if (!SWIG_IsOK(ecode3)) {
51130 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51131 }
51132 arg3 = static_cast< int >(val3);
51133 }
51134 {
51135 PyThreadState* __tstate = wxPyBeginAllowThreads();
51136 (arg1)->Below(arg2,arg3);
51137 wxPyEndAllowThreads(__tstate);
51138 if (PyErr_Occurred()) SWIG_fail;
51139 }
51140 resultobj = SWIG_Py_Void();
51141 return resultobj;
51142 fail:
51143 return NULL;
51144 }
51145
51146
51147 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51148 PyObject *resultobj = 0;
51149 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51150 wxWindow *arg2 = (wxWindow *) 0 ;
51151 wxEdge arg3 ;
51152 int arg4 = (int) 0 ;
51153 void *argp1 = 0 ;
51154 int res1 = 0 ;
51155 void *argp2 = 0 ;
51156 int res2 = 0 ;
51157 int val3 ;
51158 int ecode3 = 0 ;
51159 int val4 ;
51160 int ecode4 = 0 ;
51161 PyObject * obj0 = 0 ;
51162 PyObject * obj1 = 0 ;
51163 PyObject * obj2 = 0 ;
51164 PyObject * obj3 = 0 ;
51165 char * kwnames[] = {
51166 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51167 };
51168
51169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51171 if (!SWIG_IsOK(res1)) {
51172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51173 }
51174 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51175 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51176 if (!SWIG_IsOK(res2)) {
51177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51178 }
51179 arg2 = reinterpret_cast< wxWindow * >(argp2);
51180 ecode3 = SWIG_AsVal_int(obj2, &val3);
51181 if (!SWIG_IsOK(ecode3)) {
51182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51183 }
51184 arg3 = static_cast< wxEdge >(val3);
51185 if (obj3) {
51186 ecode4 = SWIG_AsVal_int(obj3, &val4);
51187 if (!SWIG_IsOK(ecode4)) {
51188 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51189 }
51190 arg4 = static_cast< int >(val4);
51191 }
51192 {
51193 PyThreadState* __tstate = wxPyBeginAllowThreads();
51194 (arg1)->SameAs(arg2,arg3,arg4);
51195 wxPyEndAllowThreads(__tstate);
51196 if (PyErr_Occurred()) SWIG_fail;
51197 }
51198 resultobj = SWIG_Py_Void();
51199 return resultobj;
51200 fail:
51201 return NULL;
51202 }
51203
51204
51205 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51206 PyObject *resultobj = 0;
51207 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51208 wxWindow *arg2 = (wxWindow *) 0 ;
51209 wxEdge arg3 ;
51210 int arg4 ;
51211 void *argp1 = 0 ;
51212 int res1 = 0 ;
51213 void *argp2 = 0 ;
51214 int res2 = 0 ;
51215 int val3 ;
51216 int ecode3 = 0 ;
51217 int val4 ;
51218 int ecode4 = 0 ;
51219 PyObject * obj0 = 0 ;
51220 PyObject * obj1 = 0 ;
51221 PyObject * obj2 = 0 ;
51222 PyObject * obj3 = 0 ;
51223 char * kwnames[] = {
51224 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51225 };
51226
51227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51229 if (!SWIG_IsOK(res1)) {
51230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51231 }
51232 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51233 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51234 if (!SWIG_IsOK(res2)) {
51235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51236 }
51237 arg2 = reinterpret_cast< wxWindow * >(argp2);
51238 ecode3 = SWIG_AsVal_int(obj2, &val3);
51239 if (!SWIG_IsOK(ecode3)) {
51240 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51241 }
51242 arg3 = static_cast< wxEdge >(val3);
51243 ecode4 = SWIG_AsVal_int(obj3, &val4);
51244 if (!SWIG_IsOK(ecode4)) {
51245 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51246 }
51247 arg4 = static_cast< int >(val4);
51248 {
51249 PyThreadState* __tstate = wxPyBeginAllowThreads();
51250 (arg1)->PercentOf(arg2,arg3,arg4);
51251 wxPyEndAllowThreads(__tstate);
51252 if (PyErr_Occurred()) SWIG_fail;
51253 }
51254 resultobj = SWIG_Py_Void();
51255 return resultobj;
51256 fail:
51257 return NULL;
51258 }
51259
51260
51261 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51262 PyObject *resultobj = 0;
51263 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51264 int arg2 ;
51265 void *argp1 = 0 ;
51266 int res1 = 0 ;
51267 int val2 ;
51268 int ecode2 = 0 ;
51269 PyObject * obj0 = 0 ;
51270 PyObject * obj1 = 0 ;
51271 char * kwnames[] = {
51272 (char *) "self",(char *) "val", NULL
51273 };
51274
51275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51277 if (!SWIG_IsOK(res1)) {
51278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51279 }
51280 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51281 ecode2 = SWIG_AsVal_int(obj1, &val2);
51282 if (!SWIG_IsOK(ecode2)) {
51283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51284 }
51285 arg2 = static_cast< int >(val2);
51286 {
51287 PyThreadState* __tstate = wxPyBeginAllowThreads();
51288 (arg1)->Absolute(arg2);
51289 wxPyEndAllowThreads(__tstate);
51290 if (PyErr_Occurred()) SWIG_fail;
51291 }
51292 resultobj = SWIG_Py_Void();
51293 return resultobj;
51294 fail:
51295 return NULL;
51296 }
51297
51298
51299 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51300 PyObject *resultobj = 0;
51301 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51302 void *argp1 = 0 ;
51303 int res1 = 0 ;
51304 PyObject *swig_obj[1] ;
51305
51306 if (!args) SWIG_fail;
51307 swig_obj[0] = args;
51308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51309 if (!SWIG_IsOK(res1)) {
51310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51311 }
51312 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51313 {
51314 PyThreadState* __tstate = wxPyBeginAllowThreads();
51315 (arg1)->Unconstrained();
51316 wxPyEndAllowThreads(__tstate);
51317 if (PyErr_Occurred()) SWIG_fail;
51318 }
51319 resultobj = SWIG_Py_Void();
51320 return resultobj;
51321 fail:
51322 return NULL;
51323 }
51324
51325
51326 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51327 PyObject *resultobj = 0;
51328 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51329 void *argp1 = 0 ;
51330 int res1 = 0 ;
51331 PyObject *swig_obj[1] ;
51332
51333 if (!args) SWIG_fail;
51334 swig_obj[0] = args;
51335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51336 if (!SWIG_IsOK(res1)) {
51337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51338 }
51339 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51340 {
51341 PyThreadState* __tstate = wxPyBeginAllowThreads();
51342 (arg1)->AsIs();
51343 wxPyEndAllowThreads(__tstate);
51344 if (PyErr_Occurred()) SWIG_fail;
51345 }
51346 resultobj = SWIG_Py_Void();
51347 return resultobj;
51348 fail:
51349 return NULL;
51350 }
51351
51352
51353 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51354 PyObject *resultobj = 0;
51355 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51356 wxWindow *result = 0 ;
51357 void *argp1 = 0 ;
51358 int res1 = 0 ;
51359 PyObject *swig_obj[1] ;
51360
51361 if (!args) SWIG_fail;
51362 swig_obj[0] = args;
51363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51364 if (!SWIG_IsOK(res1)) {
51365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51366 }
51367 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51368 {
51369 PyThreadState* __tstate = wxPyBeginAllowThreads();
51370 result = (wxWindow *)(arg1)->GetOtherWindow();
51371 wxPyEndAllowThreads(__tstate);
51372 if (PyErr_Occurred()) SWIG_fail;
51373 }
51374 {
51375 resultobj = wxPyMake_wxObject(result, 0);
51376 }
51377 return resultobj;
51378 fail:
51379 return NULL;
51380 }
51381
51382
51383 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51384 PyObject *resultobj = 0;
51385 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51386 wxEdge result;
51387 void *argp1 = 0 ;
51388 int res1 = 0 ;
51389 PyObject *swig_obj[1] ;
51390
51391 if (!args) SWIG_fail;
51392 swig_obj[0] = args;
51393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51394 if (!SWIG_IsOK(res1)) {
51395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51396 }
51397 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51398 {
51399 PyThreadState* __tstate = wxPyBeginAllowThreads();
51400 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51401 wxPyEndAllowThreads(__tstate);
51402 if (PyErr_Occurred()) SWIG_fail;
51403 }
51404 resultobj = SWIG_From_int(static_cast< int >(result));
51405 return resultobj;
51406 fail:
51407 return NULL;
51408 }
51409
51410
51411 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51412 PyObject *resultobj = 0;
51413 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51414 wxEdge arg2 ;
51415 void *argp1 = 0 ;
51416 int res1 = 0 ;
51417 int val2 ;
51418 int ecode2 = 0 ;
51419 PyObject * obj0 = 0 ;
51420 PyObject * obj1 = 0 ;
51421 char * kwnames[] = {
51422 (char *) "self",(char *) "which", NULL
51423 };
51424
51425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51427 if (!SWIG_IsOK(res1)) {
51428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51429 }
51430 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51431 ecode2 = SWIG_AsVal_int(obj1, &val2);
51432 if (!SWIG_IsOK(ecode2)) {
51433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51434 }
51435 arg2 = static_cast< wxEdge >(val2);
51436 {
51437 PyThreadState* __tstate = wxPyBeginAllowThreads();
51438 (arg1)->SetEdge(arg2);
51439 wxPyEndAllowThreads(__tstate);
51440 if (PyErr_Occurred()) SWIG_fail;
51441 }
51442 resultobj = SWIG_Py_Void();
51443 return resultobj;
51444 fail:
51445 return NULL;
51446 }
51447
51448
51449 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51450 PyObject *resultobj = 0;
51451 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51452 int arg2 ;
51453 void *argp1 = 0 ;
51454 int res1 = 0 ;
51455 int val2 ;
51456 int ecode2 = 0 ;
51457 PyObject * obj0 = 0 ;
51458 PyObject * obj1 = 0 ;
51459 char * kwnames[] = {
51460 (char *) "self",(char *) "v", NULL
51461 };
51462
51463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51465 if (!SWIG_IsOK(res1)) {
51466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51467 }
51468 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51469 ecode2 = SWIG_AsVal_int(obj1, &val2);
51470 if (!SWIG_IsOK(ecode2)) {
51471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51472 }
51473 arg2 = static_cast< int >(val2);
51474 {
51475 PyThreadState* __tstate = wxPyBeginAllowThreads();
51476 (arg1)->SetValue(arg2);
51477 wxPyEndAllowThreads(__tstate);
51478 if (PyErr_Occurred()) SWIG_fail;
51479 }
51480 resultobj = SWIG_Py_Void();
51481 return resultobj;
51482 fail:
51483 return NULL;
51484 }
51485
51486
51487 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51488 PyObject *resultobj = 0;
51489 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51490 int result;
51491 void *argp1 = 0 ;
51492 int res1 = 0 ;
51493 PyObject *swig_obj[1] ;
51494
51495 if (!args) SWIG_fail;
51496 swig_obj[0] = args;
51497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51498 if (!SWIG_IsOK(res1)) {
51499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51500 }
51501 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51502 {
51503 PyThreadState* __tstate = wxPyBeginAllowThreads();
51504 result = (int)(arg1)->GetMargin();
51505 wxPyEndAllowThreads(__tstate);
51506 if (PyErr_Occurred()) SWIG_fail;
51507 }
51508 resultobj = SWIG_From_int(static_cast< int >(result));
51509 return resultobj;
51510 fail:
51511 return NULL;
51512 }
51513
51514
51515 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51516 PyObject *resultobj = 0;
51517 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51518 int arg2 ;
51519 void *argp1 = 0 ;
51520 int res1 = 0 ;
51521 int val2 ;
51522 int ecode2 = 0 ;
51523 PyObject * obj0 = 0 ;
51524 PyObject * obj1 = 0 ;
51525 char * kwnames[] = {
51526 (char *) "self",(char *) "m", NULL
51527 };
51528
51529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51531 if (!SWIG_IsOK(res1)) {
51532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51533 }
51534 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51535 ecode2 = SWIG_AsVal_int(obj1, &val2);
51536 if (!SWIG_IsOK(ecode2)) {
51537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51538 }
51539 arg2 = static_cast< int >(val2);
51540 {
51541 PyThreadState* __tstate = wxPyBeginAllowThreads();
51542 (arg1)->SetMargin(arg2);
51543 wxPyEndAllowThreads(__tstate);
51544 if (PyErr_Occurred()) SWIG_fail;
51545 }
51546 resultobj = SWIG_Py_Void();
51547 return resultobj;
51548 fail:
51549 return NULL;
51550 }
51551
51552
51553 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51554 PyObject *resultobj = 0;
51555 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51556 int result;
51557 void *argp1 = 0 ;
51558 int res1 = 0 ;
51559 PyObject *swig_obj[1] ;
51560
51561 if (!args) SWIG_fail;
51562 swig_obj[0] = args;
51563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51564 if (!SWIG_IsOK(res1)) {
51565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51566 }
51567 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51568 {
51569 PyThreadState* __tstate = wxPyBeginAllowThreads();
51570 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51571 wxPyEndAllowThreads(__tstate);
51572 if (PyErr_Occurred()) SWIG_fail;
51573 }
51574 resultobj = SWIG_From_int(static_cast< int >(result));
51575 return resultobj;
51576 fail:
51577 return NULL;
51578 }
51579
51580
51581 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51582 PyObject *resultobj = 0;
51583 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51584 int result;
51585 void *argp1 = 0 ;
51586 int res1 = 0 ;
51587 PyObject *swig_obj[1] ;
51588
51589 if (!args) SWIG_fail;
51590 swig_obj[0] = args;
51591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51592 if (!SWIG_IsOK(res1)) {
51593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51594 }
51595 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51596 {
51597 PyThreadState* __tstate = wxPyBeginAllowThreads();
51598 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51599 wxPyEndAllowThreads(__tstate);
51600 if (PyErr_Occurred()) SWIG_fail;
51601 }
51602 resultobj = SWIG_From_int(static_cast< int >(result));
51603 return resultobj;
51604 fail:
51605 return NULL;
51606 }
51607
51608
51609 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51610 PyObject *resultobj = 0;
51611 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51612 int result;
51613 void *argp1 = 0 ;
51614 int res1 = 0 ;
51615 PyObject *swig_obj[1] ;
51616
51617 if (!args) SWIG_fail;
51618 swig_obj[0] = args;
51619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51620 if (!SWIG_IsOK(res1)) {
51621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51622 }
51623 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51624 {
51625 PyThreadState* __tstate = wxPyBeginAllowThreads();
51626 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51627 wxPyEndAllowThreads(__tstate);
51628 if (PyErr_Occurred()) SWIG_fail;
51629 }
51630 resultobj = SWIG_From_int(static_cast< int >(result));
51631 return resultobj;
51632 fail:
51633 return NULL;
51634 }
51635
51636
51637 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51638 PyObject *resultobj = 0;
51639 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51640 bool result;
51641 void *argp1 = 0 ;
51642 int res1 = 0 ;
51643 PyObject *swig_obj[1] ;
51644
51645 if (!args) SWIG_fail;
51646 swig_obj[0] = args;
51647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51648 if (!SWIG_IsOK(res1)) {
51649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51650 }
51651 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51652 {
51653 PyThreadState* __tstate = wxPyBeginAllowThreads();
51654 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51655 wxPyEndAllowThreads(__tstate);
51656 if (PyErr_Occurred()) SWIG_fail;
51657 }
51658 {
51659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51660 }
51661 return resultobj;
51662 fail:
51663 return NULL;
51664 }
51665
51666
51667 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51668 PyObject *resultobj = 0;
51669 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51670 bool arg2 ;
51671 void *argp1 = 0 ;
51672 int res1 = 0 ;
51673 bool val2 ;
51674 int ecode2 = 0 ;
51675 PyObject * obj0 = 0 ;
51676 PyObject * obj1 = 0 ;
51677 char * kwnames[] = {
51678 (char *) "self",(char *) "d", NULL
51679 };
51680
51681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51683 if (!SWIG_IsOK(res1)) {
51684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51685 }
51686 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51687 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51688 if (!SWIG_IsOK(ecode2)) {
51689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51690 }
51691 arg2 = static_cast< bool >(val2);
51692 {
51693 PyThreadState* __tstate = wxPyBeginAllowThreads();
51694 (arg1)->SetDone(arg2);
51695 wxPyEndAllowThreads(__tstate);
51696 if (PyErr_Occurred()) SWIG_fail;
51697 }
51698 resultobj = SWIG_Py_Void();
51699 return resultobj;
51700 fail:
51701 return NULL;
51702 }
51703
51704
51705 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51706 PyObject *resultobj = 0;
51707 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51708 wxRelationship result;
51709 void *argp1 = 0 ;
51710 int res1 = 0 ;
51711 PyObject *swig_obj[1] ;
51712
51713 if (!args) SWIG_fail;
51714 swig_obj[0] = args;
51715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51716 if (!SWIG_IsOK(res1)) {
51717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51718 }
51719 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51720 {
51721 PyThreadState* __tstate = wxPyBeginAllowThreads();
51722 result = (wxRelationship)(arg1)->GetRelationship();
51723 wxPyEndAllowThreads(__tstate);
51724 if (PyErr_Occurred()) SWIG_fail;
51725 }
51726 resultobj = SWIG_From_int(static_cast< int >(result));
51727 return resultobj;
51728 fail:
51729 return NULL;
51730 }
51731
51732
51733 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51734 PyObject *resultobj = 0;
51735 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51736 wxRelationship arg2 ;
51737 void *argp1 = 0 ;
51738 int res1 = 0 ;
51739 int val2 ;
51740 int ecode2 = 0 ;
51741 PyObject * obj0 = 0 ;
51742 PyObject * obj1 = 0 ;
51743 char * kwnames[] = {
51744 (char *) "self",(char *) "r", NULL
51745 };
51746
51747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51749 if (!SWIG_IsOK(res1)) {
51750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51751 }
51752 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51753 ecode2 = SWIG_AsVal_int(obj1, &val2);
51754 if (!SWIG_IsOK(ecode2)) {
51755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
51756 }
51757 arg2 = static_cast< wxRelationship >(val2);
51758 {
51759 PyThreadState* __tstate = wxPyBeginAllowThreads();
51760 (arg1)->SetRelationship(arg2);
51761 wxPyEndAllowThreads(__tstate);
51762 if (PyErr_Occurred()) SWIG_fail;
51763 }
51764 resultobj = SWIG_Py_Void();
51765 return resultobj;
51766 fail:
51767 return NULL;
51768 }
51769
51770
51771 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51772 PyObject *resultobj = 0;
51773 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51774 wxWindow *arg2 = (wxWindow *) 0 ;
51775 bool result;
51776 void *argp1 = 0 ;
51777 int res1 = 0 ;
51778 void *argp2 = 0 ;
51779 int res2 = 0 ;
51780 PyObject * obj0 = 0 ;
51781 PyObject * obj1 = 0 ;
51782 char * kwnames[] = {
51783 (char *) "self",(char *) "otherW", NULL
51784 };
51785
51786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
51787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51788 if (!SWIG_IsOK(res1)) {
51789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51790 }
51791 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51792 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51793 if (!SWIG_IsOK(res2)) {
51794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51795 }
51796 arg2 = reinterpret_cast< wxWindow * >(argp2);
51797 {
51798 PyThreadState* __tstate = wxPyBeginAllowThreads();
51799 result = (bool)(arg1)->ResetIfWin(arg2);
51800 wxPyEndAllowThreads(__tstate);
51801 if (PyErr_Occurred()) SWIG_fail;
51802 }
51803 {
51804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51805 }
51806 return resultobj;
51807 fail:
51808 return NULL;
51809 }
51810
51811
51812 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51813 PyObject *resultobj = 0;
51814 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51815 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
51816 wxWindow *arg3 = (wxWindow *) 0 ;
51817 bool result;
51818 void *argp1 = 0 ;
51819 int res1 = 0 ;
51820 void *argp2 = 0 ;
51821 int res2 = 0 ;
51822 void *argp3 = 0 ;
51823 int res3 = 0 ;
51824 PyObject * obj0 = 0 ;
51825 PyObject * obj1 = 0 ;
51826 PyObject * obj2 = 0 ;
51827 char * kwnames[] = {
51828 (char *) "self",(char *) "constraints",(char *) "win", NULL
51829 };
51830
51831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51833 if (!SWIG_IsOK(res1)) {
51834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51835 }
51836 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51838 if (!SWIG_IsOK(res2)) {
51839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
51840 }
51841 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
51842 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51843 if (!SWIG_IsOK(res3)) {
51844 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
51845 }
51846 arg3 = reinterpret_cast< wxWindow * >(argp3);
51847 {
51848 PyThreadState* __tstate = wxPyBeginAllowThreads();
51849 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
51850 wxPyEndAllowThreads(__tstate);
51851 if (PyErr_Occurred()) SWIG_fail;
51852 }
51853 {
51854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51855 }
51856 return resultobj;
51857 fail:
51858 return NULL;
51859 }
51860
51861
51862 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51863 PyObject *resultobj = 0;
51864 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51865 wxEdge arg2 ;
51866 wxWindow *arg3 = (wxWindow *) 0 ;
51867 wxWindow *arg4 = (wxWindow *) 0 ;
51868 int result;
51869 void *argp1 = 0 ;
51870 int res1 = 0 ;
51871 int val2 ;
51872 int ecode2 = 0 ;
51873 void *argp3 = 0 ;
51874 int res3 = 0 ;
51875 void *argp4 = 0 ;
51876 int res4 = 0 ;
51877 PyObject * obj0 = 0 ;
51878 PyObject * obj1 = 0 ;
51879 PyObject * obj2 = 0 ;
51880 PyObject * obj3 = 0 ;
51881 char * kwnames[] = {
51882 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
51883 };
51884
51885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51887 if (!SWIG_IsOK(res1)) {
51888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51889 }
51890 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51891 ecode2 = SWIG_AsVal_int(obj1, &val2);
51892 if (!SWIG_IsOK(ecode2)) {
51893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51894 }
51895 arg2 = static_cast< wxEdge >(val2);
51896 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51897 if (!SWIG_IsOK(res3)) {
51898 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
51899 }
51900 arg3 = reinterpret_cast< wxWindow * >(argp3);
51901 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
51902 if (!SWIG_IsOK(res4)) {
51903 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
51904 }
51905 arg4 = reinterpret_cast< wxWindow * >(argp4);
51906 {
51907 PyThreadState* __tstate = wxPyBeginAllowThreads();
51908 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
51909 wxPyEndAllowThreads(__tstate);
51910 if (PyErr_Occurred()) SWIG_fail;
51911 }
51912 resultobj = SWIG_From_int(static_cast< int >(result));
51913 return resultobj;
51914 fail:
51915 return NULL;
51916 }
51917
51918
51919 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51920 PyObject *obj;
51921 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51922 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
51923 return SWIG_Py_Void();
51924 }
51925
51926 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51927 PyObject *resultobj = 0;
51928 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
51929 wxIndividualLayoutConstraint *result = 0 ;
51930 void *argp1 = 0 ;
51931 int res1 = 0 ;
51932 PyObject *swig_obj[1] ;
51933
51934 if (!args) SWIG_fail;
51935 swig_obj[0] = args;
51936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51937 if (!SWIG_IsOK(res1)) {
51938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
51939 }
51940 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
51941 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
51942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51943 return resultobj;
51944 fail:
51945 return NULL;
51946 }
51947
51948
51949 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51950 PyObject *resultobj = 0;
51951 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
51952 wxIndividualLayoutConstraint *result = 0 ;
51953 void *argp1 = 0 ;
51954 int res1 = 0 ;
51955 PyObject *swig_obj[1] ;
51956
51957 if (!args) SWIG_fail;
51958 swig_obj[0] = args;
51959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51960 if (!SWIG_IsOK(res1)) {
51961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
51962 }
51963 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
51964 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
51965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51966 return resultobj;
51967 fail:
51968 return NULL;
51969 }
51970
51971
51972 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51973 PyObject *resultobj = 0;
51974 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
51975 wxIndividualLayoutConstraint *result = 0 ;
51976 void *argp1 = 0 ;
51977 int res1 = 0 ;
51978 PyObject *swig_obj[1] ;
51979
51980 if (!args) SWIG_fail;
51981 swig_obj[0] = args;
51982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51983 if (!SWIG_IsOK(res1)) {
51984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
51985 }
51986 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
51987 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
51988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51989 return resultobj;
51990 fail:
51991 return NULL;
51992 }
51993
51994
51995 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51996 PyObject *resultobj = 0;
51997 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
51998 wxIndividualLayoutConstraint *result = 0 ;
51999 void *argp1 = 0 ;
52000 int res1 = 0 ;
52001 PyObject *swig_obj[1] ;
52002
52003 if (!args) SWIG_fail;
52004 swig_obj[0] = args;
52005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52006 if (!SWIG_IsOK(res1)) {
52007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52008 }
52009 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52010 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52012 return resultobj;
52013 fail:
52014 return NULL;
52015 }
52016
52017
52018 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52019 PyObject *resultobj = 0;
52020 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52021 wxIndividualLayoutConstraint *result = 0 ;
52022 void *argp1 = 0 ;
52023 int res1 = 0 ;
52024 PyObject *swig_obj[1] ;
52025
52026 if (!args) SWIG_fail;
52027 swig_obj[0] = args;
52028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52029 if (!SWIG_IsOK(res1)) {
52030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52031 }
52032 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52033 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52035 return resultobj;
52036 fail:
52037 return NULL;
52038 }
52039
52040
52041 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52042 PyObject *resultobj = 0;
52043 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52044 wxIndividualLayoutConstraint *result = 0 ;
52045 void *argp1 = 0 ;
52046 int res1 = 0 ;
52047 PyObject *swig_obj[1] ;
52048
52049 if (!args) SWIG_fail;
52050 swig_obj[0] = args;
52051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52052 if (!SWIG_IsOK(res1)) {
52053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52054 }
52055 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52056 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52058 return resultobj;
52059 fail:
52060 return NULL;
52061 }
52062
52063
52064 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52065 PyObject *resultobj = 0;
52066 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52067 wxIndividualLayoutConstraint *result = 0 ;
52068 void *argp1 = 0 ;
52069 int res1 = 0 ;
52070 PyObject *swig_obj[1] ;
52071
52072 if (!args) SWIG_fail;
52073 swig_obj[0] = args;
52074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52075 if (!SWIG_IsOK(res1)) {
52076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52077 }
52078 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52079 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52081 return resultobj;
52082 fail:
52083 return NULL;
52084 }
52085
52086
52087 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52088 PyObject *resultobj = 0;
52089 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52090 wxIndividualLayoutConstraint *result = 0 ;
52091 void *argp1 = 0 ;
52092 int res1 = 0 ;
52093 PyObject *swig_obj[1] ;
52094
52095 if (!args) SWIG_fail;
52096 swig_obj[0] = args;
52097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52098 if (!SWIG_IsOK(res1)) {
52099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52100 }
52101 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52102 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52104 return resultobj;
52105 fail:
52106 return NULL;
52107 }
52108
52109
52110 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52111 PyObject *resultobj = 0;
52112 wxLayoutConstraints *result = 0 ;
52113
52114 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52115 {
52116 PyThreadState* __tstate = wxPyBeginAllowThreads();
52117 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52118 wxPyEndAllowThreads(__tstate);
52119 if (PyErr_Occurred()) SWIG_fail;
52120 }
52121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52122 return resultobj;
52123 fail:
52124 return NULL;
52125 }
52126
52127
52128 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52129 PyObject *resultobj = 0;
52130 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52131 void *argp1 = 0 ;
52132 int res1 = 0 ;
52133 PyObject *swig_obj[1] ;
52134
52135 if (!args) SWIG_fail;
52136 swig_obj[0] = args;
52137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52138 if (!SWIG_IsOK(res1)) {
52139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52140 }
52141 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52142 {
52143 PyThreadState* __tstate = wxPyBeginAllowThreads();
52144 delete arg1;
52145
52146 wxPyEndAllowThreads(__tstate);
52147 if (PyErr_Occurred()) SWIG_fail;
52148 }
52149 resultobj = SWIG_Py_Void();
52150 return resultobj;
52151 fail:
52152 return NULL;
52153 }
52154
52155
52156 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52157 PyObject *resultobj = 0;
52158 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52159 wxWindow *arg2 = (wxWindow *) 0 ;
52160 int *arg3 = (int *) 0 ;
52161 bool result;
52162 void *argp1 = 0 ;
52163 int res1 = 0 ;
52164 void *argp2 = 0 ;
52165 int res2 = 0 ;
52166 int temp3 ;
52167 int res3 = SWIG_TMPOBJ ;
52168 PyObject * obj0 = 0 ;
52169 PyObject * obj1 = 0 ;
52170 char * kwnames[] = {
52171 (char *) "self",(char *) "win", NULL
52172 };
52173
52174 arg3 = &temp3;
52175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52177 if (!SWIG_IsOK(res1)) {
52178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52179 }
52180 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52181 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52182 if (!SWIG_IsOK(res2)) {
52183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52184 }
52185 arg2 = reinterpret_cast< wxWindow * >(argp2);
52186 {
52187 PyThreadState* __tstate = wxPyBeginAllowThreads();
52188 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52189 wxPyEndAllowThreads(__tstate);
52190 if (PyErr_Occurred()) SWIG_fail;
52191 }
52192 {
52193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52194 }
52195 if (SWIG_IsTmpObj(res3)) {
52196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52197 } else {
52198 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52200 }
52201 return resultobj;
52202 fail:
52203 return NULL;
52204 }
52205
52206
52207 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52208 PyObject *resultobj = 0;
52209 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52210 bool result;
52211 void *argp1 = 0 ;
52212 int res1 = 0 ;
52213 PyObject *swig_obj[1] ;
52214
52215 if (!args) SWIG_fail;
52216 swig_obj[0] = args;
52217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52218 if (!SWIG_IsOK(res1)) {
52219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52220 }
52221 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52222 {
52223 PyThreadState* __tstate = wxPyBeginAllowThreads();
52224 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52225 wxPyEndAllowThreads(__tstate);
52226 if (PyErr_Occurred()) SWIG_fail;
52227 }
52228 {
52229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52230 }
52231 return resultobj;
52232 fail:
52233 return NULL;
52234 }
52235
52236
52237 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52238 PyObject *obj;
52239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52240 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52241 return SWIG_Py_Void();
52242 }
52243
52244 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52245 return SWIG_Python_InitShadowInstance(args);
52246 }
52247
52248 static PyMethodDef SwigMethods[] = {
52249 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52250 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
52251 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52252 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52253 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52254 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52255 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52256 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52257 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52258 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52259 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52260 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52261 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52262 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52263 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52264 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52265 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52266 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52267 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52268 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52269 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52270 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52271 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52272 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52273 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52274 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52275 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52276 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52277 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52278 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52279 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52280 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52281 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52282 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52283 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52284 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52285 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52286 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52287 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52288 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52289 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52290 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52291 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52292 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52293 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52294 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52295 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52296 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52297 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52298 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52299 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52300 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52301 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52302 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52303 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52304 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52305 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52306 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52307 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52308 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52309 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52310 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52311 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52312 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52313 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52314 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52315 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52316 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52317 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52318 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52319 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52320 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52321 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52322 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52323 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52324 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52325 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52326 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52327 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52328 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52329 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52330 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52331 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52332 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52333 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52334 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52335 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52336 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52337 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52338 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52339 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52340 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52341 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52342 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52343 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52344 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52345 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52346 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52347 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52348 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52349 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52350 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52351 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52352 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52353 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52354 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52355 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52356 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52357 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52358 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52359 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52360 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52361 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52362 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52363 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52364 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52365 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52366 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52367 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52368 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52369 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52370 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52371 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52372 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52373 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52374 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52375 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52376 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52377 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52378 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52379 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52380 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52381 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52382 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52383 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52384 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52385 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52386 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52387 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52388 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52389 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52390 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52391 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52392 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52393 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52394 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52395 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52396 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52397 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52398 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52399 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52400 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52401 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52402 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52403 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52404 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52405 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52406 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52407 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52408 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52409 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52410 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52411 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52412 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52413 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52414 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52415 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52416 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52417 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52418 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52419 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52420 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52421 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52422 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52423 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52424 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52425 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52426 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52427 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52428 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52429 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52430 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52431 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52432 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52433 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52434 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52435 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52436 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52437 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52438 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52439 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52440 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52441 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52442 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52443 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52444 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52445 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52446 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52447 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52448 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52449 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52450 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52451 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52452 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52453 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52454 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52455 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52456 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52457 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52458 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52459 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52460 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52461 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52462 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52463 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52464 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52465 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52466 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52467 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52468 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52469 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52470 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52471 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52472 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52473 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52474 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52475 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52476 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52477 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52478 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52479 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52480 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52481 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52482 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52483 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52484 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52485 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52486 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52487 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52488 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52489 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52490 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52491 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52492 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52493 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52494 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52495 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52496 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52497 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52498 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52499 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52500 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52501 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52502 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52503 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52504 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52505 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52506 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52507 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52508 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52509 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52510 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52511 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52512 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52513 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52514 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52515 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52516 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52517 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52518 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52519 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52520 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52521 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52522 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52523 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52524 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52525 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52526 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52527 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52528 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52529 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52530 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52531 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52532 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52533 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52534 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52535 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52536 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52537 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52538 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52539 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52540 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52541 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52542 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52543 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52544 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52545 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52546 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52547 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52548 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52549 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52550 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52551 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52552 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52553 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52554 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52555 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52556 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52557 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52558 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52559 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52560 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52561 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52562 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52563 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52564 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52565 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52566 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52567 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52568 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52569 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52570 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52571 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52572 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52573 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52574 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52575 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52576 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52577 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52578 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52579 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52580 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52581 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52582 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52583 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52584 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52585 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52586 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52587 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52588 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52589 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52590 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52591 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52592 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52593 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52594 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52595 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52596 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52597 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52598 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52599 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52600 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52601 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52602 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52603 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52604 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52605 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52606 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52607 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52608 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52609 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52610 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52611 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52612 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52613 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52614 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52615 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52616 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52617 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52618 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52619 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52620 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52621 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52622 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52623 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52624 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52625 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52626 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52627 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52628 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52629 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52630 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52631 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52632 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52633 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52634 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52635 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52636 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52637 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52638 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52639 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52640 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52641 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52642 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52643 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52644 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52645 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52646 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52647 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52648 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52649 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52650 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52651 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52653 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52654 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52655 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52656 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52657 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52658 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52659 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52660 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52661 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52662 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52663 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52664 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52665 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52666 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52667 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52668 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52669 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52670 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52671 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52672 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52673 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52674 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52675 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52676 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52677 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52678 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52679 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52680 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52681 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52682 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52683 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52684 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52685 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52686 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52687 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52688 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52689 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52690 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52692 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52693 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52694 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52695 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52696 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52697 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52698 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52699 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52700 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52701 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52702 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52703 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52704 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52705 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52706 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52707 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52708 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52709 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52710 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52711 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52712 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52713 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52714 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52715 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52716 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52717 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52718 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52719 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52720 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52721 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52722 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52723 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52724 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52725 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52726 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52727 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52728 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52729 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52730 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52731 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52732 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52733 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52734 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52735 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52736 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52737 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52738 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52739 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52740 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52741 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52743 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52744 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52745 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52746 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52747 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52748 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52749 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52750 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52751 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
52752 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
52753 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
52754 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
52755 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
52756 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
52757 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
52758 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
52759 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
52760 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
52761 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
52762 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
52763 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
52764 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
52765 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
52766 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
52767 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
52768 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
52769 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
52770 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
52771 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
52772 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
52773 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
52774 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52775 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
52776 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
52777 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
52778 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
52779 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
52780 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
52781 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
52782 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52783 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
52784 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
52785 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
52786 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
52787 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
52788 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
52789 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
52790 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
52791 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
52792 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
52793 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
52794 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
52795 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
52796 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
52797 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
52798 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
52799 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
52800 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
52801 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
52802 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
52803 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
52804 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
52805 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
52806 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
52807 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
52808 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
52809 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
52810 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
52811 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
52812 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
52813 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
52814 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
52815 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
52816 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
52817 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
52818 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
52819 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
52820 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
52822 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
52823 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52825 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
52826 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
52827 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
52828 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
52829 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
52830 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
52831 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52832 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
52833 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
52834 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52835 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
52837 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
52838 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52839 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
52840 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
52841 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
52843 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
52844 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
52846 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
52847 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
52848 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52849 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
52850 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
52851 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
52852 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
52853 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
52855 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
52856 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
52857 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52858 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
52859 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
52860 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
52861 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
52863 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
52864 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
52866 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
52867 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
52868 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
52869 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
52870 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52871 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
52873 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
52874 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
52875 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
52877 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
52878 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
52879 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
52882 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
52883 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
52884 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
52886 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
52887 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
52888 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
52890 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
52891 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
52892 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
52893 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
52894 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
52895 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52896 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
52897 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
52898 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
52899 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
52900 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
52901 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
52902 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
52903 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
52904 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
52905 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
52909 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
52910 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
52912 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
52914 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
52915 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
52916 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
52917 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
52918 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
52919 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
52921 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
52922 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
52923 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
52924 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
52925 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
52926 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
52929 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
52930 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
52931 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
52933 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
52934 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
52935 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
52936 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
52937 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
52938 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
52940 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
52942 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
52943 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
52945 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
52946 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
52947 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
52948 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
52950 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
52951 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
52952 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
52954 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
52955 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
52956 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
52958 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52959 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
52960 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
52961 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
52962 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
52963 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
52964 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
52966 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
52967 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
52968 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
52969 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52970 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
52971 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52972 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
52973 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
52974 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
52975 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52976 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
52977 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52978 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
52979 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
52980 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
52981 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52982 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
52983 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
52984 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
52985 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
52986 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
52987 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
52988 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52989 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
52990 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
52991 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
52992 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
52994 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
52995 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
52996 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
52997 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
52998 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
52999 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53000 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53001 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53002 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53003 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53004 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53005 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53006 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53008 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53009 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53010 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53012 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53014 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53015 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53016 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53018 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53019 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53020 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53021 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53022 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53023 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53025 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53028 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53029 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53030 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53031 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53032 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53033 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53034 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53035 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53037 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53038 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53039 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53040 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53041 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53042 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53043 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53044 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53045 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53046 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53047 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53048 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53049 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53050 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53051 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53052 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53053 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53054 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53055 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53056 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53057 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53059 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53061 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53062 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53063 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53064 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53065 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53067 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53068 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53069 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53070 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53072 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53073 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53074 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53075 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53076 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53077 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53078 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53079 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53080 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53081 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53082 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53083 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53086 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53087 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53088 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53090 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53091 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53092 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53094 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53096 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53097 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53106 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53107 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53108 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53112 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53113 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53114 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53115 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53116 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53117 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53118 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53119 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53120 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53121 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53122 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53123 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53125 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53126 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53129 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53130 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53135 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53136 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53139 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53140 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53141 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53142 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53145 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53146 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53147 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53149 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53151 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53152 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53153 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53155 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53157 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53159 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53162 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53163 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53164 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53165 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53166 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53167 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53168 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53169 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53171 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53174 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53175 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53176 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53177 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53178 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53179 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53183 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53189 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53190 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53191 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53192 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53193 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53195 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53198 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53203 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53204 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53205 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53206 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53207 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53208 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53211 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53212 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53213 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53214 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53215 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53216 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53217 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53220 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53221 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53224 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53225 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53227 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53228 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53229 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53230 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53231 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53232 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53233 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53234 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53235 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53238 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53240 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53241 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53242 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53245 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53251 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53253 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53255 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53257 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53265 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53266 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53267 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53268 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53269 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53270 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53271 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53274 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53277 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53278 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53279 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53280 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53282 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53284 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53285 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53288 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53290 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53291 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53292 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53293 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53294 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53296 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53299 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53300 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53301 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53303 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53304 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53305 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53307 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53309 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53310 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53311 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53313 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53314 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53317 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53320 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53324 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53331 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53339 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53341 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53342 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53343 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53349 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53356 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53358 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53360 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53361 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53363 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53365 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53366 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53367 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53368 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53369 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53370 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53374 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53392 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53393 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53394 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53396 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53398 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53399 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53400 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53402 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53403 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53406 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53407 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53409 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53410 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53412 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53415 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53416 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53418 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53420 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53422 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53423 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53425 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53426 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53429 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53431 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53433 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53435 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53438 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53440 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53441 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53442 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53444 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53445 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53446 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53448 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53451 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53453 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53454 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53458 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53462 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53463 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53465 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53469 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53471 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53473 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53474 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53475 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53476 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53480 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53481 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53482 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53483 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53485 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53486 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53491 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53492 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53493 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53494 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53495 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53497 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53499 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53501 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53502 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53504 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53506 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53509 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53510 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53511 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53513 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53514 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53515 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53529 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53530 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53531 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53532 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53533 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53534 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53540 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53541 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53542 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53544 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53545 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53546 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53548 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53549 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53551 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53553 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53554 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53556 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53557 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53558 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53564 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53565 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53566 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53567 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53568 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53569 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53576 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53578 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53579 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53580 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53581 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53582 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53583 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53585 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53589 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53590 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53591 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53592 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53593 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53594 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53595 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53597 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53598 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53599 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53601 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53605 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53606 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53607 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53609 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53610 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53611 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53617 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53618 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53619 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53620 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53621 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53625 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53626 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53631 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53632 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53634 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53635 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53637 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53640 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53642 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53643 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53644 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53645 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53646 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53651 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53652 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53661 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53662 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53663 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53664 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53667 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53669 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53670 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53671 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53672 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53674 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53679 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53680 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53681 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53682 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53683 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53684 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53685 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53686 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53687 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53688 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53689 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53691 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53692 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53693 { NULL, NULL, 0, NULL }
53694 };
53695
53696
53697 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53698
53699 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53700 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53701 }
53702 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53703 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53704 }
53705 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53706 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53707 }
53708 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53709 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53710 }
53711 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53712 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53713 }
53714 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53715 return (void *)((wxSizer *) ((wxGridSizer *) x));
53716 }
53717 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53718 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53719 }
53720 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53721 return (void *)((wxSizer *) ((wxPySizer *) x));
53722 }
53723 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53724 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53725 }
53726 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53727 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53728 }
53729 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53730 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53731 }
53732 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53733 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53734 }
53735 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53736 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53737 }
53738 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53739 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53740 }
53741 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53742 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53743 }
53744 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53745 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53746 }
53747 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
53748 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
53749 }
53750 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
53751 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
53752 }
53753 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
53754 return (void *)((wxEvent *) ((wxPyEvent *) x));
53755 }
53756 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
53757 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
53758 }
53759 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
53760 return (void *)((wxEvent *) ((wxIdleEvent *) x));
53761 }
53762 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
53763 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
53764 }
53765 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
53766 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
53767 }
53768 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
53769 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
53770 }
53771 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
53772 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
53773 }
53774 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
53775 return (void *)((wxEvent *) ((wxActivateEvent *) x));
53776 }
53777 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
53778 return (void *)((wxEvent *) ((wxSizeEvent *) x));
53779 }
53780 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
53781 return (void *)((wxEvent *) ((wxMoveEvent *) x));
53782 }
53783 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
53784 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
53785 }
53786 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
53787 return (void *)((wxEvent *) ((wxPaintEvent *) x));
53788 }
53789 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
53790 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
53791 }
53792 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
53793 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
53794 }
53795 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
53796 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
53797 }
53798 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
53799 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
53800 }
53801 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
53802 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
53803 }
53804 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
53805 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
53806 }
53807 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
53808 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
53809 }
53810 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
53811 return (void *)((wxEvent *) ((wxFocusEvent *) x));
53812 }
53813 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
53814 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
53815 }
53816 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
53817 return (void *)((wxEvent *) ((wxShowEvent *) x));
53818 }
53819 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
53820 return (void *)((wxEvent *) ((wxCommandEvent *) x));
53821 }
53822 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
53823 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
53824 }
53825 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
53826 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
53827 }
53828 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
53829 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
53830 }
53831 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
53832 return (void *)((wxEvent *) ((wxKeyEvent *) x));
53833 }
53834 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
53835 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
53836 }
53837 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
53838 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
53839 }
53840 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
53841 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
53842 }
53843 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
53844 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
53845 }
53846 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
53847 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
53848 }
53849 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
53850 return (void *)((wxControl *) ((wxControlWithItems *) x));
53851 }
53852 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
53853 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
53854 }
53855 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
53856 return (void *)((wxEvtHandler *) ((wxWindow *) x));
53857 }
53858 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
53859 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
53860 }
53861 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
53862 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
53863 }
53864 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
53865 return (void *)((wxEvtHandler *) ((wxValidator *) x));
53866 }
53867 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
53868 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
53869 }
53870 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
53871 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
53872 }
53873 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
53874 return (void *)((wxEvtHandler *) ((wxMenu *) x));
53875 }
53876 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
53877 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
53878 }
53879 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
53880 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
53881 }
53882 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
53883 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
53884 }
53885 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
53886 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
53887 }
53888 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
53889 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
53890 }
53891 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
53892 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
53893 }
53894 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
53895 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
53896 }
53897 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
53898 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
53899 }
53900 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
53901 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
53902 }
53903 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
53904 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
53905 }
53906 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
53907 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
53908 }
53909 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
53910 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
53911 }
53912 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
53913 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
53914 }
53915 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
53916 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
53917 }
53918 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
53919 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
53920 }
53921 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
53922 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
53923 }
53924 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
53925 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
53926 }
53927 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
53928 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
53929 }
53930 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
53931 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
53932 }
53933 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
53934 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
53935 }
53936 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
53937 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
53938 }
53939 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
53940 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
53941 }
53942 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
53943 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
53944 }
53945 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
53946 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
53947 }
53948 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
53949 return (void *)((wxObject *) ((wxSizerItem *) x));
53950 }
53951 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
53952 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
53953 }
53954 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
53955 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
53956 }
53957 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
53958 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
53959 }
53960 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
53961 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
53962 }
53963 static void *_p_wxSizerTo_p_wxObject(void *x) {
53964 return (void *)((wxObject *) ((wxSizer *) x));
53965 }
53966 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
53967 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53968 }
53969 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
53970 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
53971 }
53972 static void *_p_wxEventTo_p_wxObject(void *x) {
53973 return (void *)((wxObject *) ((wxEvent *) x));
53974 }
53975 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
53976 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
53977 }
53978 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
53979 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
53980 }
53981 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
53982 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
53983 }
53984 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
53985 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
53986 }
53987 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
53988 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
53989 }
53990 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
53991 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
53992 }
53993 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
53994 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
53995 }
53996 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
53997 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
53998 }
53999 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54000 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54001 }
54002 static void *_p_wxControlTo_p_wxObject(void *x) {
54003 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54004 }
54005 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54006 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54007 }
54008 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54009 return (void *)((wxObject *) ((wxFSFile *) x));
54010 }
54011 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54012 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54013 }
54014 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54015 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54016 }
54017 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54018 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54019 }
54020 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54021 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54022 }
54023 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54024 return (void *)((wxObject *) ((wxMenuItem *) x));
54025 }
54026 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54027 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54028 }
54029 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54030 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54031 }
54032 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54033 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54034 }
54035 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54036 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54037 }
54038 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54039 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54040 }
54041 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54042 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54043 }
54044 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54045 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54046 }
54047 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54048 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54049 }
54050 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54051 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54052 }
54053 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54054 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54055 }
54056 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54057 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54058 }
54059 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54060 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54061 }
54062 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54063 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54064 }
54065 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54066 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54067 }
54068 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54069 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54070 }
54071 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54072 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54073 }
54074 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54075 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54076 }
54077 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54078 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54079 }
54080 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54081 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54082 }
54083 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54084 return (void *)((wxObject *) ((wxImageHandler *) x));
54085 }
54086 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54087 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54088 }
54089 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54090 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54091 }
54092 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54093 return (void *)((wxObject *) ((wxEvtHandler *) x));
54094 }
54095 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54096 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54097 }
54098 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54099 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54100 }
54101 static void *_p_wxImageTo_p_wxObject(void *x) {
54102 return (void *)((wxObject *) ((wxImage *) x));
54103 }
54104 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54105 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54106 }
54107 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54108 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54109 }
54110 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54111 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54112 }
54113 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54114 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54115 }
54116 static void *_p_wxWindowTo_p_wxObject(void *x) {
54117 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54118 }
54119 static void *_p_wxMenuTo_p_wxObject(void *x) {
54120 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54121 }
54122 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54123 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54124 }
54125 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54126 return (void *)((wxObject *) ((wxFileSystem *) x));
54127 }
54128 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54129 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54130 }
54131 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54132 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54133 }
54134 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54135 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54136 }
54137 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54138 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54139 }
54140 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54141 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54142 }
54143 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54144 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54145 }
54146 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54147 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54148 }
54149 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54150 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54151 }
54152 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54153 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54154 }
54155 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54156 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54157 }
54158 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54159 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54160 }
54161 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54162 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54163 }
54164 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54165 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54166 }
54167 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54168 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54169 }
54170 static void *_p_wxControlTo_p_wxWindow(void *x) {
54171 return (void *)((wxWindow *) ((wxControl *) x));
54172 }
54173 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54174 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54175 }
54176 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54177 return (void *)((wxWindow *) ((wxMenuBar *) x));
54178 }
54179 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54180 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54181 }
54182 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54183 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54184 }
54185 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54186 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54187 }
54188 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54189 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54190 }
54191 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54192 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54193 }
54194 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54195 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54196 }
54197 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54198 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54199 }
54200 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54201 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54202 }
54203 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54204 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54205 }
54206 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54207 return (void *)((wxValidator *) ((wxPyValidator *) x));
54208 }
54209 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54210 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54211 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};
54212 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54213 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54214 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54215 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54216 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54217 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54218 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54219 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54220 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54221 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54222 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54223 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54224 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54225 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54226 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54227 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54228 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54229 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54230 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54231 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54232 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54233 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54234 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54235 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54236 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54237 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54238 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54239 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54240 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54241 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54242 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54243 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54244 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54245 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54246 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54247 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54248 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54249 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54250 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54251 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54252 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54253 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54254 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54255 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54256 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54257 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54258 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54259 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54260 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54261 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54262 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54263 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54264 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54265 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54266 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54267 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54268 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54269 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54270 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54271 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54272 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54273 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54274 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54275 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54276 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54277 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54278 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54279 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54280 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54281 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54282 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54283 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54284 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54285 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54286 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54287 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54288 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54289 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54290 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54291 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54292 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54293 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54294 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54295 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54296 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54297 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54298 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54299 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54300 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54301 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54302 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54303 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54304 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54305 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54306 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54307 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54308 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54309 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54310 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54311 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54312 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54313 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54314 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54315 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54316 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54317 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54318 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54319 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54320 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54321 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54322 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54323 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54324 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54325 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54326 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54327 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54328 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54329 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54330 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54331 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54332 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54333 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54334 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54335 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54336 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54337 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54338
54339 static swig_type_info *swig_type_initial[] = {
54340 &_swigt__p_buffer,
54341 &_swigt__p_char,
54342 &_swigt__p_form_ops_t,
54343 &_swigt__p_int,
54344 &_swigt__p_long,
54345 &_swigt__p_unsigned_char,
54346 &_swigt__p_unsigned_int,
54347 &_swigt__p_unsigned_long,
54348 &_swigt__p_wxANIHandler,
54349 &_swigt__p_wxAcceleratorEntry,
54350 &_swigt__p_wxAcceleratorTable,
54351 &_swigt__p_wxActivateEvent,
54352 &_swigt__p_wxAppTraits,
54353 &_swigt__p_wxArrayString,
54354 &_swigt__p_wxBMPHandler,
54355 &_swigt__p_wxBitmap,
54356 &_swigt__p_wxBoxSizer,
54357 &_swigt__p_wxButton,
54358 &_swigt__p_wxCURHandler,
54359 &_swigt__p_wxCaret,
54360 &_swigt__p_wxChildFocusEvent,
54361 &_swigt__p_wxCloseEvent,
54362 &_swigt__p_wxColour,
54363 &_swigt__p_wxCommandEvent,
54364 &_swigt__p_wxContextMenuEvent,
54365 &_swigt__p_wxControl,
54366 &_swigt__p_wxControlWithItems,
54367 &_swigt__p_wxCursor,
54368 &_swigt__p_wxDC,
54369 &_swigt__p_wxDateEvent,
54370 &_swigt__p_wxDateTime,
54371 &_swigt__p_wxDisplayChangedEvent,
54372 &_swigt__p_wxDropFilesEvent,
54373 &_swigt__p_wxDuplexMode,
54374 &_swigt__p_wxEraseEvent,
54375 &_swigt__p_wxEvent,
54376 &_swigt__p_wxEventLoop,
54377 &_swigt__p_wxEventLoopActivator,
54378 &_swigt__p_wxEvtHandler,
54379 &_swigt__p_wxFSFile,
54380 &_swigt__p_wxFileSystem,
54381 &_swigt__p_wxFileSystemHandler,
54382 &_swigt__p_wxFlexGridSizer,
54383 &_swigt__p_wxFocusEvent,
54384 &_swigt__p_wxFont,
54385 &_swigt__p_wxFrame,
54386 &_swigt__p_wxGBPosition,
54387 &_swigt__p_wxGBSizerItem,
54388 &_swigt__p_wxGBSpan,
54389 &_swigt__p_wxGIFHandler,
54390 &_swigt__p_wxGridBagSizer,
54391 &_swigt__p_wxGridSizer,
54392 &_swigt__p_wxICOHandler,
54393 &_swigt__p_wxIconizeEvent,
54394 &_swigt__p_wxIdleEvent,
54395 &_swigt__p_wxImage,
54396 &_swigt__p_wxImageHandler,
54397 &_swigt__p_wxImageHistogram,
54398 &_swigt__p_wxImage_HSVValue,
54399 &_swigt__p_wxImage_RGBValue,
54400 &_swigt__p_wxIndividualLayoutConstraint,
54401 &_swigt__p_wxInitDialogEvent,
54402 &_swigt__p_wxInputStream,
54403 &_swigt__p_wxInternetFSHandler,
54404 &_swigt__p_wxItemContainer,
54405 &_swigt__p_wxJPEGHandler,
54406 &_swigt__p_wxKeyEvent,
54407 &_swigt__p_wxLayoutConstraints,
54408 &_swigt__p_wxMaximizeEvent,
54409 &_swigt__p_wxMemoryFSHandler,
54410 &_swigt__p_wxMenu,
54411 &_swigt__p_wxMenuBar,
54412 &_swigt__p_wxMenuBarBase,
54413 &_swigt__p_wxMenuEvent,
54414 &_swigt__p_wxMenuItem,
54415 &_swigt__p_wxMouseCaptureChangedEvent,
54416 &_swigt__p_wxMouseEvent,
54417 &_swigt__p_wxMoveEvent,
54418 &_swigt__p_wxNavigationKeyEvent,
54419 &_swigt__p_wxNcPaintEvent,
54420 &_swigt__p_wxNotifyEvent,
54421 &_swigt__p_wxObject,
54422 &_swigt__p_wxOutputStream,
54423 &_swigt__p_wxPCXHandler,
54424 &_swigt__p_wxPNGHandler,
54425 &_swigt__p_wxPNMHandler,
54426 &_swigt__p_wxPaintEvent,
54427 &_swigt__p_wxPaletteChangedEvent,
54428 &_swigt__p_wxPaperSize,
54429 &_swigt__p_wxPoint,
54430 &_swigt__p_wxPoint2D,
54431 &_swigt__p_wxPropagateOnce,
54432 &_swigt__p_wxPropagationDisabler,
54433 &_swigt__p_wxPyApp,
54434 &_swigt__p_wxPyCommandEvent,
54435 &_swigt__p_wxPyDropTarget,
54436 &_swigt__p_wxPyEvent,
54437 &_swigt__p_wxPyFileSystemHandler,
54438 &_swigt__p_wxPyImageHandler,
54439 &_swigt__p_wxPyInputStream,
54440 &_swigt__p_wxPySizer,
54441 &_swigt__p_wxPyValidator,
54442 &_swigt__p_wxQuantize,
54443 &_swigt__p_wxQueryNewPaletteEvent,
54444 &_swigt__p_wxRealPoint,
54445 &_swigt__p_wxRect,
54446 &_swigt__p_wxRegion,
54447 &_swigt__p_wxScrollEvent,
54448 &_swigt__p_wxScrollWinEvent,
54449 &_swigt__p_wxSetCursorEvent,
54450 &_swigt__p_wxShowEvent,
54451 &_swigt__p_wxSize,
54452 &_swigt__p_wxSizeEvent,
54453 &_swigt__p_wxSizer,
54454 &_swigt__p_wxSizerItem,
54455 &_swigt__p_wxStaticBox,
54456 &_swigt__p_wxStaticBoxSizer,
54457 &_swigt__p_wxStdDialogButtonSizer,
54458 &_swigt__p_wxSysColourChangedEvent,
54459 &_swigt__p_wxTIFFHandler,
54460 &_swigt__p_wxToolTip,
54461 &_swigt__p_wxUpdateUIEvent,
54462 &_swigt__p_wxValidator,
54463 &_swigt__p_wxVisualAttributes,
54464 &_swigt__p_wxWindow,
54465 &_swigt__p_wxWindowCreateEvent,
54466 &_swigt__p_wxWindowDestroyEvent,
54467 &_swigt__p_wxXPMHandler,
54468 &_swigt__p_wxZipFSHandler,
54469 };
54470
54471 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54472 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54473 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54474 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54475 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54476 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54477 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54478 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54479 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54480 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54481 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54482 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54483 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54484 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54485 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}};
54486 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54487 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}};
54488 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54489 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}};
54490 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54491 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54492 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54493 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54494 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
54495 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54496 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}};
54497 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54498 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54499 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54500 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54501 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54502 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54503 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54504 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54505 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54506 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
54507 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54508 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54509 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}};
54510 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54511 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54512 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}};
54513 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}};
54514 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54515 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54516 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54517 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54518 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54519 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54520 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54521 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54522 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}};
54523 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}};
54524 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54525 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54526 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54527 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}};
54528 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54529 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54530 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54531 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54532 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54533 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54534 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54535 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}};
54536 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54537 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54538 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54539 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54540 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54541 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54542 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54543 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54544 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54545 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54546 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54547 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54548 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54549 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54550 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54551 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54552 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
54553 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54554 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54555 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54556 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54557 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54558 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54559 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54560 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54561 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54562 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54563 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54564 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54565 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54566 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54567 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54568 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54569 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54570 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54571 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54572 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54573 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54574 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54575 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54576 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54577 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54578 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54579 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54580 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54581 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54582 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54583 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54584 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}};
54585 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}};
54586 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54587 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54588 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54589 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54590 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54591 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54592 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54593 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}};
54594 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54595 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}};
54596 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54597 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54598 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54599 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54600
54601 static swig_cast_info *swig_cast_initial[] = {
54602 _swigc__p_buffer,
54603 _swigc__p_char,
54604 _swigc__p_form_ops_t,
54605 _swigc__p_int,
54606 _swigc__p_long,
54607 _swigc__p_unsigned_char,
54608 _swigc__p_unsigned_int,
54609 _swigc__p_unsigned_long,
54610 _swigc__p_wxANIHandler,
54611 _swigc__p_wxAcceleratorEntry,
54612 _swigc__p_wxAcceleratorTable,
54613 _swigc__p_wxActivateEvent,
54614 _swigc__p_wxAppTraits,
54615 _swigc__p_wxArrayString,
54616 _swigc__p_wxBMPHandler,
54617 _swigc__p_wxBitmap,
54618 _swigc__p_wxBoxSizer,
54619 _swigc__p_wxButton,
54620 _swigc__p_wxCURHandler,
54621 _swigc__p_wxCaret,
54622 _swigc__p_wxChildFocusEvent,
54623 _swigc__p_wxCloseEvent,
54624 _swigc__p_wxColour,
54625 _swigc__p_wxCommandEvent,
54626 _swigc__p_wxContextMenuEvent,
54627 _swigc__p_wxControl,
54628 _swigc__p_wxControlWithItems,
54629 _swigc__p_wxCursor,
54630 _swigc__p_wxDC,
54631 _swigc__p_wxDateEvent,
54632 _swigc__p_wxDateTime,
54633 _swigc__p_wxDisplayChangedEvent,
54634 _swigc__p_wxDropFilesEvent,
54635 _swigc__p_wxDuplexMode,
54636 _swigc__p_wxEraseEvent,
54637 _swigc__p_wxEvent,
54638 _swigc__p_wxEventLoop,
54639 _swigc__p_wxEventLoopActivator,
54640 _swigc__p_wxEvtHandler,
54641 _swigc__p_wxFSFile,
54642 _swigc__p_wxFileSystem,
54643 _swigc__p_wxFileSystemHandler,
54644 _swigc__p_wxFlexGridSizer,
54645 _swigc__p_wxFocusEvent,
54646 _swigc__p_wxFont,
54647 _swigc__p_wxFrame,
54648 _swigc__p_wxGBPosition,
54649 _swigc__p_wxGBSizerItem,
54650 _swigc__p_wxGBSpan,
54651 _swigc__p_wxGIFHandler,
54652 _swigc__p_wxGridBagSizer,
54653 _swigc__p_wxGridSizer,
54654 _swigc__p_wxICOHandler,
54655 _swigc__p_wxIconizeEvent,
54656 _swigc__p_wxIdleEvent,
54657 _swigc__p_wxImage,
54658 _swigc__p_wxImageHandler,
54659 _swigc__p_wxImageHistogram,
54660 _swigc__p_wxImage_HSVValue,
54661 _swigc__p_wxImage_RGBValue,
54662 _swigc__p_wxIndividualLayoutConstraint,
54663 _swigc__p_wxInitDialogEvent,
54664 _swigc__p_wxInputStream,
54665 _swigc__p_wxInternetFSHandler,
54666 _swigc__p_wxItemContainer,
54667 _swigc__p_wxJPEGHandler,
54668 _swigc__p_wxKeyEvent,
54669 _swigc__p_wxLayoutConstraints,
54670 _swigc__p_wxMaximizeEvent,
54671 _swigc__p_wxMemoryFSHandler,
54672 _swigc__p_wxMenu,
54673 _swigc__p_wxMenuBar,
54674 _swigc__p_wxMenuBarBase,
54675 _swigc__p_wxMenuEvent,
54676 _swigc__p_wxMenuItem,
54677 _swigc__p_wxMouseCaptureChangedEvent,
54678 _swigc__p_wxMouseEvent,
54679 _swigc__p_wxMoveEvent,
54680 _swigc__p_wxNavigationKeyEvent,
54681 _swigc__p_wxNcPaintEvent,
54682 _swigc__p_wxNotifyEvent,
54683 _swigc__p_wxObject,
54684 _swigc__p_wxOutputStream,
54685 _swigc__p_wxPCXHandler,
54686 _swigc__p_wxPNGHandler,
54687 _swigc__p_wxPNMHandler,
54688 _swigc__p_wxPaintEvent,
54689 _swigc__p_wxPaletteChangedEvent,
54690 _swigc__p_wxPaperSize,
54691 _swigc__p_wxPoint,
54692 _swigc__p_wxPoint2D,
54693 _swigc__p_wxPropagateOnce,
54694 _swigc__p_wxPropagationDisabler,
54695 _swigc__p_wxPyApp,
54696 _swigc__p_wxPyCommandEvent,
54697 _swigc__p_wxPyDropTarget,
54698 _swigc__p_wxPyEvent,
54699 _swigc__p_wxPyFileSystemHandler,
54700 _swigc__p_wxPyImageHandler,
54701 _swigc__p_wxPyInputStream,
54702 _swigc__p_wxPySizer,
54703 _swigc__p_wxPyValidator,
54704 _swigc__p_wxQuantize,
54705 _swigc__p_wxQueryNewPaletteEvent,
54706 _swigc__p_wxRealPoint,
54707 _swigc__p_wxRect,
54708 _swigc__p_wxRegion,
54709 _swigc__p_wxScrollEvent,
54710 _swigc__p_wxScrollWinEvent,
54711 _swigc__p_wxSetCursorEvent,
54712 _swigc__p_wxShowEvent,
54713 _swigc__p_wxSize,
54714 _swigc__p_wxSizeEvent,
54715 _swigc__p_wxSizer,
54716 _swigc__p_wxSizerItem,
54717 _swigc__p_wxStaticBox,
54718 _swigc__p_wxStaticBoxSizer,
54719 _swigc__p_wxStdDialogButtonSizer,
54720 _swigc__p_wxSysColourChangedEvent,
54721 _swigc__p_wxTIFFHandler,
54722 _swigc__p_wxToolTip,
54723 _swigc__p_wxUpdateUIEvent,
54724 _swigc__p_wxValidator,
54725 _swigc__p_wxVisualAttributes,
54726 _swigc__p_wxWindow,
54727 _swigc__p_wxWindowCreateEvent,
54728 _swigc__p_wxWindowDestroyEvent,
54729 _swigc__p_wxXPMHandler,
54730 _swigc__p_wxZipFSHandler,
54731 };
54732
54733
54734 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54735
54736 static swig_const_info swig_const_table[] = {
54737 {0, 0, 0, 0.0, 0, 0}};
54738
54739 #ifdef __cplusplus
54740 }
54741 #endif
54742 /* -----------------------------------------------------------------------------
54743 * Type initialization:
54744 * This problem is tough by the requirement that no dynamic
54745 * memory is used. Also, since swig_type_info structures store pointers to
54746 * swig_cast_info structures and swig_cast_info structures store pointers back
54747 * to swig_type_info structures, we need some lookup code at initialization.
54748 * The idea is that swig generates all the structures that are needed.
54749 * The runtime then collects these partially filled structures.
54750 * The SWIG_InitializeModule function takes these initial arrays out of
54751 * swig_module, and does all the lookup, filling in the swig_module.types
54752 * array with the correct data and linking the correct swig_cast_info
54753 * structures together.
54754 *
54755 * The generated swig_type_info structures are assigned staticly to an initial
54756 * array. We just loop though that array, and handle each type individually.
54757 * First we lookup if this type has been already loaded, and if so, use the
54758 * loaded structure instead of the generated one. Then we have to fill in the
54759 * cast linked list. The cast data is initially stored in something like a
54760 * two-dimensional array. Each row corresponds to a type (there are the same
54761 * number of rows as there are in the swig_type_initial array). Each entry in
54762 * a column is one of the swig_cast_info structures for that type.
54763 * The cast_initial array is actually an array of arrays, because each row has
54764 * a variable number of columns. So to actually build the cast linked list,
54765 * we find the array of casts associated with the type, and loop through it
54766 * adding the casts to the list. The one last trick we need to do is making
54767 * sure the type pointer in the swig_cast_info struct is correct.
54768 *
54769 * First off, we lookup the cast->type name to see if it is already loaded.
54770 * There are three cases to handle:
54771 * 1) If the cast->type has already been loaded AND the type we are adding
54772 * casting info to has not been loaded (it is in this module), THEN we
54773 * replace the cast->type pointer with the type pointer that has already
54774 * been loaded.
54775 * 2) If BOTH types (the one we are adding casting info to, and the
54776 * cast->type) are loaded, THEN the cast info has already been loaded by
54777 * the previous module so we just ignore it.
54778 * 3) Finally, if cast->type has not already been loaded, then we add that
54779 * swig_cast_info to the linked list (because the cast->type) pointer will
54780 * be correct.
54781 * ----------------------------------------------------------------------------- */
54782
54783 #ifdef __cplusplus
54784 extern "C" {
54785 #if 0
54786 } /* c-mode */
54787 #endif
54788 #endif
54789
54790 #if 0
54791 #define SWIGRUNTIME_DEBUG
54792 #endif
54793
54794 SWIGRUNTIME void
54795 SWIG_InitializeModule(void *clientdata) {
54796 size_t i;
54797 swig_module_info *module_head;
54798 static int init_run = 0;
54799
54800 clientdata = clientdata;
54801
54802 if (init_run) return;
54803 init_run = 1;
54804
54805 /* Initialize the swig_module */
54806 swig_module.type_initial = swig_type_initial;
54807 swig_module.cast_initial = swig_cast_initial;
54808
54809 /* Try and load any already created modules */
54810 module_head = SWIG_GetModule(clientdata);
54811 if (module_head) {
54812 swig_module.next = module_head->next;
54813 module_head->next = &swig_module;
54814 } else {
54815 /* This is the first module loaded */
54816 swig_module.next = &swig_module;
54817 SWIG_SetModule(clientdata, &swig_module);
54818 }
54819
54820 /* Now work on filling in swig_module.types */
54821 #ifdef SWIGRUNTIME_DEBUG
54822 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
54823 #endif
54824 for (i = 0; i < swig_module.size; ++i) {
54825 swig_type_info *type = 0;
54826 swig_type_info *ret;
54827 swig_cast_info *cast;
54828
54829 #ifdef SWIGRUNTIME_DEBUG
54830 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
54831 #endif
54832
54833 /* if there is another module already loaded */
54834 if (swig_module.next != &swig_module) {
54835 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
54836 }
54837 if (type) {
54838 /* Overwrite clientdata field */
54839 #ifdef SWIGRUNTIME_DEBUG
54840 printf("SWIG_InitializeModule: found type %s\n", type->name);
54841 #endif
54842 if (swig_module.type_initial[i]->clientdata) {
54843 type->clientdata = swig_module.type_initial[i]->clientdata;
54844 #ifdef SWIGRUNTIME_DEBUG
54845 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
54846 #endif
54847 }
54848 } else {
54849 type = swig_module.type_initial[i];
54850 }
54851
54852 /* Insert casting types */
54853 cast = swig_module.cast_initial[i];
54854 while (cast->type) {
54855 /* Don't need to add information already in the list */
54856 ret = 0;
54857 #ifdef SWIGRUNTIME_DEBUG
54858 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
54859 #endif
54860 if (swig_module.next != &swig_module) {
54861 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
54862 #ifdef SWIGRUNTIME_DEBUG
54863 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
54864 #endif
54865 }
54866 if (ret) {
54867 if (type == swig_module.type_initial[i]) {
54868 #ifdef SWIGRUNTIME_DEBUG
54869 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
54870 #endif
54871 cast->type = ret;
54872 ret = 0;
54873 } else {
54874 /* Check for casting already in the list */
54875 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
54876 #ifdef SWIGRUNTIME_DEBUG
54877 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
54878 #endif
54879 if (!ocast) ret = 0;
54880 }
54881 }
54882
54883 if (!ret) {
54884 #ifdef SWIGRUNTIME_DEBUG
54885 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
54886 #endif
54887 if (type->cast) {
54888 type->cast->prev = cast;
54889 cast->next = type->cast;
54890 }
54891 type->cast = cast;
54892 }
54893 cast++;
54894 }
54895 /* Set entry in modules->types array equal to the type */
54896 swig_module.types[i] = type;
54897 }
54898 swig_module.types[i] = 0;
54899
54900 #ifdef SWIGRUNTIME_DEBUG
54901 printf("**** SWIG_InitializeModule: Cast List ******\n");
54902 for (i = 0; i < swig_module.size; ++i) {
54903 int j = 0;
54904 swig_cast_info *cast = swig_module.cast_initial[i];
54905 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
54906 while (cast->type) {
54907 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
54908 cast++;
54909 ++j;
54910 }
54911 printf("---- Total casts: %d\n",j);
54912 }
54913 printf("**** SWIG_InitializeModule: Cast List ******\n");
54914 #endif
54915 }
54916
54917 /* This function will propagate the clientdata field of type to
54918 * any new swig_type_info structures that have been added into the list
54919 * of equivalent types. It is like calling
54920 * SWIG_TypeClientData(type, clientdata) a second time.
54921 */
54922 SWIGRUNTIME void
54923 SWIG_PropagateClientData(void) {
54924 size_t i;
54925 swig_cast_info *equiv;
54926 static int init_run = 0;
54927
54928 if (init_run) return;
54929 init_run = 1;
54930
54931 for (i = 0; i < swig_module.size; i++) {
54932 if (swig_module.types[i]->clientdata) {
54933 equiv = swig_module.types[i]->cast;
54934 while (equiv) {
54935 if (!equiv->converter) {
54936 if (equiv->type && !equiv->type->clientdata)
54937 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
54938 }
54939 equiv = equiv->next;
54940 }
54941 }
54942 }
54943 }
54944
54945 #ifdef __cplusplus
54946 #if 0
54947 {
54948 /* c-mode */
54949 #endif
54950 }
54951 #endif
54952
54953
54954
54955 #ifdef __cplusplus
54956 extern "C" {
54957 #endif
54958
54959 /* Python-specific SWIG API */
54960 #define SWIG_newvarlink() SWIG_Python_newvarlink()
54961 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
54962 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
54963
54964 /* -----------------------------------------------------------------------------
54965 * global variable support code.
54966 * ----------------------------------------------------------------------------- */
54967
54968 typedef struct swig_globalvar {
54969 char *name; /* Name of global variable */
54970 PyObject *(*get_attr)(void); /* Return the current value */
54971 int (*set_attr)(PyObject *); /* Set the value */
54972 struct swig_globalvar *next;
54973 } swig_globalvar;
54974
54975 typedef struct swig_varlinkobject {
54976 PyObject_HEAD
54977 swig_globalvar *vars;
54978 } swig_varlinkobject;
54979
54980 SWIGINTERN PyObject *
54981 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
54982 return PyString_FromString("<Swig global variables>");
54983 }
54984
54985 SWIGINTERN PyObject *
54986 swig_varlink_str(swig_varlinkobject *v) {
54987 PyObject *str = PyString_FromString("(");
54988 swig_globalvar *var;
54989 for (var = v->vars; var; var=var->next) {
54990 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
54991 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
54992 }
54993 PyString_ConcatAndDel(&str,PyString_FromString(")"));
54994 return str;
54995 }
54996
54997 SWIGINTERN int
54998 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
54999 PyObject *str = swig_varlink_str(v);
55000 fprintf(fp,"Swig global variables ");
55001 fprintf(fp,"%s\n", PyString_AsString(str));
55002 Py_DECREF(str);
55003 return 0;
55004 }
55005
55006 SWIGINTERN void
55007 swig_varlink_dealloc(swig_varlinkobject *v) {
55008 swig_globalvar *var = v->vars;
55009 while (var) {
55010 swig_globalvar *n = var->next;
55011 free(var->name);
55012 free(var);
55013 var = n;
55014 }
55015 }
55016
55017 SWIGINTERN PyObject *
55018 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55019 PyObject *res = NULL;
55020 swig_globalvar *var = v->vars;
55021 while (var) {
55022 if (strcmp(var->name,n) == 0) {
55023 res = (*var->get_attr)();
55024 break;
55025 }
55026 var = var->next;
55027 }
55028 if (res == NULL && !PyErr_Occurred()) {
55029 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55030 }
55031 return res;
55032 }
55033
55034 SWIGINTERN int
55035 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55036 int res = 1;
55037 swig_globalvar *var = v->vars;
55038 while (var) {
55039 if (strcmp(var->name,n) == 0) {
55040 res = (*var->set_attr)(p);
55041 break;
55042 }
55043 var = var->next;
55044 }
55045 if (res == 1 && !PyErr_Occurred()) {
55046 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55047 }
55048 return res;
55049 }
55050
55051 SWIGINTERN PyTypeObject*
55052 swig_varlink_type(void) {
55053 static char varlink__doc__[] = "Swig var link object";
55054 static PyTypeObject varlink_type;
55055 static int type_init = 0;
55056 if (!type_init) {
55057 const PyTypeObject tmp
55058 = {
55059 PyObject_HEAD_INIT(NULL)
55060 0, /* Number of items in variable part (ob_size) */
55061 (char *)"swigvarlink", /* Type name (tp_name) */
55062 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55063 0, /* Itemsize (tp_itemsize) */
55064 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55065 (printfunc) swig_varlink_print, /* Print (tp_print) */
55066 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55067 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55068 0, /* tp_compare */
55069 (reprfunc) swig_varlink_repr, /* tp_repr */
55070 0, /* tp_as_number */
55071 0, /* tp_as_sequence */
55072 0, /* tp_as_mapping */
55073 0, /* tp_hash */
55074 0, /* tp_call */
55075 (reprfunc)swig_varlink_str, /* tp_str */
55076 0, /* tp_getattro */
55077 0, /* tp_setattro */
55078 0, /* tp_as_buffer */
55079 0, /* tp_flags */
55080 varlink__doc__, /* tp_doc */
55081 0, /* tp_traverse */
55082 0, /* tp_clear */
55083 0, /* tp_richcompare */
55084 0, /* tp_weaklistoffset */
55085 #if PY_VERSION_HEX >= 0x02020000
55086 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55087 #endif
55088 #if PY_VERSION_HEX >= 0x02030000
55089 0, /* tp_del */
55090 #endif
55091 #ifdef COUNT_ALLOCS
55092 0,0,0,0 /* tp_alloc -> tp_next */
55093 #endif
55094 };
55095 varlink_type = tmp;
55096 varlink_type.ob_type = &PyType_Type;
55097 type_init = 1;
55098 }
55099 return &varlink_type;
55100 }
55101
55102 /* Create a variable linking object for use later */
55103 SWIGINTERN PyObject *
55104 SWIG_Python_newvarlink(void) {
55105 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55106 if (result) {
55107 result->vars = 0;
55108 }
55109 return ((PyObject*) result);
55110 }
55111
55112 SWIGINTERN void
55113 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55114 swig_varlinkobject *v = (swig_varlinkobject *) p;
55115 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55116 if (gv) {
55117 size_t size = strlen(name)+1;
55118 gv->name = (char *)malloc(size);
55119 if (gv->name) {
55120 strncpy(gv->name,name,size);
55121 gv->get_attr = get_attr;
55122 gv->set_attr = set_attr;
55123 gv->next = v->vars;
55124 }
55125 }
55126 v->vars = gv;
55127 }
55128
55129 SWIGINTERN PyObject *
55130 SWIG_globals() {
55131 static PyObject *_SWIG_globals = 0;
55132 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55133 return _SWIG_globals;
55134 }
55135
55136 /* -----------------------------------------------------------------------------
55137 * constants/methods manipulation
55138 * ----------------------------------------------------------------------------- */
55139
55140 /* Install Constants */
55141 SWIGINTERN void
55142 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55143 PyObject *obj = 0;
55144 size_t i;
55145 for (i = 0; constants[i].type; ++i) {
55146 switch(constants[i].type) {
55147 case SWIG_PY_POINTER:
55148 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55149 break;
55150 case SWIG_PY_BINARY:
55151 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55152 break;
55153 default:
55154 obj = 0;
55155 break;
55156 }
55157 if (obj) {
55158 PyDict_SetItemString(d, constants[i].name, obj);
55159 Py_DECREF(obj);
55160 }
55161 }
55162 }
55163
55164 /* -----------------------------------------------------------------------------*/
55165 /* Fix SwigMethods to carry the callback ptrs when needed */
55166 /* -----------------------------------------------------------------------------*/
55167
55168 SWIGINTERN void
55169 SWIG_Python_FixMethods(PyMethodDef *methods,
55170 swig_const_info *const_table,
55171 swig_type_info **types,
55172 swig_type_info **types_initial) {
55173 size_t i;
55174 for (i = 0; methods[i].ml_name; ++i) {
55175 char *c = methods[i].ml_doc;
55176 if (c && (c = strstr(c, "swig_ptr: "))) {
55177 int j;
55178 swig_const_info *ci = 0;
55179 char *name = c + 10;
55180 for (j = 0; const_table[j].type; ++j) {
55181 if (strncmp(const_table[j].name, name,
55182 strlen(const_table[j].name)) == 0) {
55183 ci = &(const_table[j]);
55184 break;
55185 }
55186 }
55187 if (ci) {
55188 size_t shift = (ci->ptype) - types;
55189 swig_type_info *ty = types_initial[shift];
55190 size_t ldoc = (c - methods[i].ml_doc);
55191 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55192 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55193 if (ndoc) {
55194 char *buff = ndoc;
55195 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55196 if (ptr) {
55197 strncpy(buff, methods[i].ml_doc, ldoc);
55198 buff += ldoc;
55199 strncpy(buff, "swig_ptr: ", 10);
55200 buff += 10;
55201 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55202 methods[i].ml_doc = ndoc;
55203 }
55204 }
55205 }
55206 }
55207 }
55208 }
55209
55210 #ifdef __cplusplus
55211 }
55212 #endif
55213
55214 /* -----------------------------------------------------------------------------*
55215 * Partial Init method
55216 * -----------------------------------------------------------------------------*/
55217
55218 #ifdef __cplusplus
55219 extern "C"
55220 #endif
55221 SWIGEXPORT void SWIG_init(void) {
55222 PyObject *m, *d;
55223
55224 /* Fix SwigMethods to carry the callback ptrs when needed */
55225 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55226
55227 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55228 d = PyModule_GetDict(m);
55229
55230 SWIG_InitializeModule(0);
55231 SWIG_InstallConstants(d,swig_const_table);
55232
55233
55234
55235 #ifndef wxPyUSE_EXPORT
55236 // Make our API structure a CObject so other modules can import it
55237 // from this module.
55238 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55239 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55240 Py_XDECREF(cobj);
55241 #endif
55242
55243 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55244 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55245 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55246 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55247 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55248 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55249 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55250 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55251 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55252 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55253 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55254 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55255 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55256 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55257 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55258 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55259 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55260 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55261 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55262 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55263 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55264 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55265 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55266 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55267 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55268 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55269 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55270 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55271 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55272 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55273 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55274 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55275 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55276 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55277 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55278 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55279 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55280 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55281 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55282 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55283 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55284 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55285 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55286 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55287 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55288 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55289 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55290 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55291 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55292 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55293 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55294 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55295 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55296 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55297 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55298 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55299 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55300 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55301 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55302 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55303 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55304 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55305 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55306 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55307 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55308 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55309 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55310 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55311 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55312 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55313 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55314 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55315 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55316 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55317 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55318 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55319 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55320 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55321 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55322 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55323 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55324 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55325 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55326 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55327 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55328 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55329 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55330 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55331 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55332 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55333 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55334 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55335 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55336 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55337 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55338 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55339 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55340 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55341 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55342 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55343 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55344 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55345 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55346 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55347 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55348 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55349 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55350 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55351 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55352 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55353 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55354 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55355 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55356 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55357 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55358 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55359 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55360 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55361 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55362 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55363 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55364 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55365 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55366 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55367 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55368 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55369 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55370 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55371 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55372 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55373 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55374 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55375 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55376 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55377 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55378 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55379 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55380 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55381 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55382 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55383 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55384 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55385 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55386 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55387 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55388 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55389 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55390 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55391 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55392 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55393 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55394 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55395 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55396 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55397 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55398 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55399 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55400 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55401 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55402 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55403 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55404 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55405 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55406 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55407 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55408 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55409 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55410 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55411 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55412 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55413 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55414 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55415 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55416 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55417 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55418 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55419 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55420 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55421 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55422 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55423 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55424 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55425 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55426 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55427 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55428 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55429 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55430 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55431 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55432 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55433 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55434 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55435 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55436 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55437 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55438 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55439 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55440 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55441 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55442 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55443 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55444 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55445 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55446 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55447 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55448 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55449 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55450 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55451 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55452 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55453 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55454 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55455 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55456 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55457 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55458 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55459 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55460 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55461 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55462 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55463 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55464 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55465 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55466 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55467 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55468 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55469 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55470 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55471 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55472 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55473 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55474 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55475 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55476 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55477 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55478 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55479 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55480 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55481 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55482 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55483 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55484 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55485 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55486 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55487 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55488 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55489 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55490 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55491 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55492 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55493 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55494 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55495 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55496 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55497 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55498 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55499 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55500 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55501 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55502 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55503 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55504 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55505 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55506 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55507 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55508 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55509 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55510 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55511 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55512 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55513 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55514 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55515 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55516 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55517 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55518 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55519 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55520 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55521 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55522 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55523 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55524 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55525 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55526 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55527 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55528 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55529 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55530 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55531 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55532 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55533 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55534 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55535 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55536 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55537 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55538 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55539 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55540 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55541 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55542 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55543 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55544 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55545 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55546 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55547 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55548 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55549 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55550 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55551 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55552 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55553 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55554 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55555 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55556 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55557 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55558 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55559 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55560 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55561 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55562 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55563 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55564 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55565 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55566 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55567 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55568 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55569 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55570 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55571 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55572 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55573 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55574 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55575 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55576 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55577 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55578 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55579 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55580 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55581 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55582 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55583 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55584 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55585 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55586 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55587 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55588 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55589 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55590 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55591 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55592 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55593 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55594 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55595 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55596 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55597 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55598 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55599 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55600 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55601 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55602 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55603 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55604 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55605 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55606 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55607 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55608 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55609 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55610 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55611 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55612 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55613 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55614 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55615 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55616 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55617 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55618 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55619 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55620 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55621 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55622 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55623 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55624 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55625 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55626 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55627 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55628 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55629 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55630 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55631 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55632 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55633 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55634 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55635 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55636 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55637 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55638 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55639 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55640 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55641 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55642 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55643 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55644 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55645 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55646 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55647 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55648 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55649 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55650 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55651 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55652 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55653 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55654 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55655 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55656 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55657 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55658 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55659 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55660 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55661 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55662 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55663 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55664 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55665 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55666 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55667 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55668 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55669 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55670 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55671 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55672 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55673 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55674 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55675 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55676 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55677 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55678 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55679 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55680 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55681 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55682 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55683 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55684 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55685 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55686 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55687 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55688 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55689 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55690 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55691 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55692 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55693 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55694 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55695 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55696 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55697 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55698 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55699 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55700 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55701 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55702 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55703 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55704 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55705 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55706 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55707 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55708 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55709 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55710 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55711 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55712 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55713 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55714 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55715 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55716 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55717 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55718 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55719 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55720 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55721 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55722 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55723 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55724 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55725 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55726 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55727 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55728 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55729 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55730 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55731 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55732 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55733 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55734 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55735 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55736 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55737 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55738 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55739 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55740 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55741 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55742 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55743 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55744 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
55745 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
55746 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
55747 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
55748 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
55749 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
55750 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
55751 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
55752 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
55753 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
55754 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
55755 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
55756 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
55757 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
55758 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
55759 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
55760 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
55761 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
55762 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
55763 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
55764 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
55765 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
55766 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
55767 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
55768 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
55769 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
55770 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
55771 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
55772 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
55773 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
55774 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
55775 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
55776 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
55777 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
55778 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
55779 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
55780 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
55781 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
55782 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
55783 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
55784 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
55785 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
55786 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
55787 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
55788 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
55789 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
55790 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
55791 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
55792 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
55793 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
55794 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
55795 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
55796 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
55797 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
55798 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
55799 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
55800 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
55801 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
55802 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
55803 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
55804 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
55805 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
55806 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
55807 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
55808 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
55809 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
55810 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
55811 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
55812 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
55813 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
55814 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
55815 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
55816 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
55817 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
55818 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
55819 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
55820 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
55821 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
55822 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
55823 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
55824 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
55825 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
55826 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
55827 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
55828 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
55829 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
55830 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
55831 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
55832 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
55833 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
55834 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
55835 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
55836 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
55837 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
55838 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
55839 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
55840 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
55841 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
55842 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
55843 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
55844 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
55845 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
55846 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
55847 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
55848 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
55849 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
55850 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
55851 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
55852 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
55853 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
55854 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
55855 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
55856 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
55857 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
55858 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
55859 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
55860 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
55861 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
55862 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
55863 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
55864 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
55865 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
55866 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
55867 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
55868 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
55869 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
55870 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
55871 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
55872 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
55873 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
55874 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
55875 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
55876 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
55877 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
55878 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
55879 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
55880 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
55881 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
55882 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
55883 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
55884 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
55885 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
55886 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
55887 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
55888 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
55889 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
55890 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
55891 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
55892 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
55893 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
55894 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
55895 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
55896 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
55897 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
55898 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
55899 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
55900 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
55901 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
55902 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
55903 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
55904 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
55905 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
55906 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
55907 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
55908 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
55909 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
55910 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
55911 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
55912
55913 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
55914
55915
55916 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
55917
55918 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
55919 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
55920 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
55921 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
55922 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
55923 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
55924 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
55925 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
55926 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
55927 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
55928 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
55929 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
55930 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
55931 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
55932 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
55933 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
55934 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
55935 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
55936 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
55937 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
55938 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
55939 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
55940 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
55941 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
55942 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
55943 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
55944 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
55945 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
55946 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
55947 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
55948 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
55949 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
55950 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
55951 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
55952 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
55953 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
55954 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
55955 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
55956 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
55957 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
55958 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
55959 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
55960 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
55961 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
55962 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
55963 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
55964 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
55965 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
55966 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
55967 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
55968 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
55969 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
55970 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
55971 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
55972 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
55973 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
55974 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
55975 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
55976 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
55977 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
55978 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
55979 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
55980 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
55981 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
55982 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
55983 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
55984 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
55985 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
55986 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
55987 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
55988 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
55989 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
55990 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
55991 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
55992 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
55993 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
55994 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
55995 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
55996 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
55997 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
55998 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
55999 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56000 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56001 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56002 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56003 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56004 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56005 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56006 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56007 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56008 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56009 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56010 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56011 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56012 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56013 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56014 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56015 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56016 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56017 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56018 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56019 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56020 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56021 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56022 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56023 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56024 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56025 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56026 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56027 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56028 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56029 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56030 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56031 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56032 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56033 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56034 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56035 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56036 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56037 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56038 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56039 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56040 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56041 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56042 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56043 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56044 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56045 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56046 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56047 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56048 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56049 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56050 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56051 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56052 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56053 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56054 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56055 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56056 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56057 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56058 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56059 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56060 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56061 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56062 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56063 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56064 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56065 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56066 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56067 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56068 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56069 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56070 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56071 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56072 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56073 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56074 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56075 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56076 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56077 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56078 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56079 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56080 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56081 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56082 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56083 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56084 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56085 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56086 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56087 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56088 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56089 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56090 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56091 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56092 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56093 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56094 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56095 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56096 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56097 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56098 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56099 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56100 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56101 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56102 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56103 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56104 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56105 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56106 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56107 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56108 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56109 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56110 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56111 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56112 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56113 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56114 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56115 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56116 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56117 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56118 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56119 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56120 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56121 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56122
56123 // Initialize threading, some globals and such
56124 __wxPyPreStart(d);
56125
56126
56127 // Although these are defined in __version__ they need to be here too so
56128 // that an assert can be done to ensure that the wxPython and the wxWindows
56129 // versions match.
56130 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56131 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56132 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56133
56134 }
56135
wxWidgets (Impactor)